www.2527.com_澳门新葡8455手机版_新京葡娱乐场网址_
做最好的网站

读书笔记,数据库操作Memcache

2019-05-02 15:06 来源:未知

缓存

python---Redis 学习笔记,python---redis

缓存

前言:

世家都听过缓存,缓存是干啥的呢?大家得以和json和pickle来讲,三个程序之间实现消息交互,能够由此在A程序中把多少改成json ,然后传给B程序,通过文件这么些介质。文件那些效能非常低。

比如说一个是QQ,三个是微信,我们想要落成多头的相互,大家以前学了rabbitMQ,可以实现新闻的传递;对于数据的共享,qq存款和储蓄的数额微信能够直接得到,这么些数量是放在内部存款和储蓄器中的,那我们怎么得以实现多个内部存款和储蓄器共享呢?大家要有一个中间商,中间商再运行多个独自的次第,自身开荒一块内存,QQ和中间商建设构造一个socket,微信和中路商业创立一个socket,那样就兑现了多中国少年共产党享。那其中间商就是缓存。

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

一、Memcached

前言:

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:设置变量,并且只好存活二分钟

 

Memcached 是一个高质量的遍布式内部存款和储蓄器对象缓存系统,用于动态Web应用以缓慢化解数据库负载。它通过在内存中缓存数据和目的来压缩读取数据库的次数,从而升高动态、数据库驱动网站的进程。Memcached基于三个存款和储蓄键/值对的hashmap。其守护进度(daemon )是用C写的,可是客户端能够用别样语言来编排,并经过memcached协议与护理过程通讯。

世家都听过缓存,缓存是干啥的啊?大家得以和json和pickle来讲,多少个程序之间达成音讯互相,能够经过在A程序中把数据改成json ,然后传给B程序,通过文件这几个介质。文件那一个作用异常低。

python使用redis

安装redis模块:

sudo pip install redis
or
sudo easy_install redis

 

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

  连接情势,连接池,操作(String操作,Hash操作,List操作,Set操作,Sort Set 操作),管道,宣布订阅

一.操作情势

两个类: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使用连接池来治本对3个redis server的具备连接,防止每一趟建立,释放连接的开销。暗许各样redis实例都会维护3个要好的连接池,能够平素创立一个连接池,然后作为参数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()转变个方式二进制,然后从后往前数6位,不足补0,正是这一个字母的2进制值

何以时候会用呢?

腾讯网今日头条在线用户会有那一个,假设做多少解析,想要看目前有怎么样用户在线,用数据库的效用是不高的。大家先看一下和命令bitcount,用来计数变量的二进制中有多少个一,如a:0b1一千0一,bitcount的结果正是三

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

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

 

图片 1

这正是说数据库中每种用户的id是头一无二的,从一起来活动抬高,参与大家有贰亿的用户,有1亿在线,大家要总计那一亿用户到底是什么人在线,大家能够透过改2进制位来促成,即: (n二是四个新的变量)

加盟有四个用户id为1000的用户登入,大家设置:setbit n二 一千 1,又登入了2个id为55伍的用户:setbit n二 55五 一;用户id为四千的用户:setbit n二 五千 一;大家用bitcount来探望n2:

图片 2

证实在线用户有二个,那就兑现了总括了在线用户人数,然后我们要探望究竟是何人在线了,用户id是稍稍本人就取多少位,大家循环那个2进制的值就能够看看是相应的不得了人在线,比方

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

图片 3

作者们想看看用户55伍在不在线:

图片 4

我们有贰亿用户,最多也就攻下二亿位,未有占多大空间,借使是用查看数据库的点子去看什么人在线的话,那表的笔录就可怜大,查询起来也要命慢。

 

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,假使存在再次回到一,不设有重返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就起到3个过滤的功效。

图片 19

本条意思正是在info2中从第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列表,里面有一个因素,放在列表的最右侧

有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

便是做八个改变数据的操作,把第多少个因素改造值

 

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列表中的第3个因素移出了

 

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

 

lrange(name, start, end):

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

 图片 28

把names列表中有着的要素都抽出来正是0,-一.然后大家可以看来我们后边存进去的先抽取来,说明列表是先入后出

 图片 29

获得names中从第一个到第五个因素,默许是从0算起的,

ltrim(name, start, end):

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

 图片 30

移出除了第一第陆个因素之外的具有的要素

 

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里面有成分就立刻删除,担负就等候肆s。

这里有一个运用:笔者把时间设置成40,然后在开发银行二个redis客户端,然后在那40s之内本身在给names加多2个新的成分,然后那边等待的客户端就应声把那一个值抽取来了

图片 33图片 34

近日一定于运营了七个经过,2个足以往列表中放入值,一个足以从列表中取值,有点像队列,想生产者消费者,因为除去的时候会再次来到删除的值就也就是抽出来数据

brpoplpush(src, dst, timeout=0)

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

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

 图片 35

不畏把names二的元素移到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中插入了多少个值,可是在联谊中实际上就只有二个值,所以说集合是不允许再次的列表

sadd(name,values):name对应的集合中添欧成分

scard(name): 获取name对应的成团瓜月素的个数

sdiff(keys, *args):在率先个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

收获集结names叁的全部值

 

smove(src, dst, value):将有些成员从3个聚众中移动到别的三个成团

spop(name):从集结的右侧(后面部分)移除几个成员,并将其归来

srandmember(name, numbers):从name对应的会聚中随机获取 numbers 个要素

srem(name, values):在name对应的联谊中删去有个别值

sunion(keys, *args):获取多2个name对应的集纳的并集

sunionstore(dest,keys, *args):获取多2个name对应的谋面的并集,并将结果保存到dest对应的集聚中

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None):同字符串的操作,用于增量迭代分批获取成分,制止内部存款和储蓄器消耗太大

 

以不改变应万变集中,在集结的根基上,为每成分排序;成分的排序须要依靠别的1个值来张开相比较,所以,对于有序聚集,每三个因素有四个值,即:值和分数,分数专门用来做排序。

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暗许有拾伍个db,从0-1五 ,能够用select 实行切换

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

type(name):获取name对应值的品种

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

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

4.管道:

redis-py私下认可在实践每回请求都会创建(连接池申请连接)和断开(归还连接池)叁次三番五次操作,假若想要在1遍呼吁中钦点几个指令,则足以应用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

 

学习笔记,python---redis 缓存 前言: 大家都听过缓存,缓存是干啥的吗?大家能够和json和pickle来讲,多个程序之间达成消息交互...

一、安装和骨干使用

比方说多少个是QQ,三个是微信,大家想要完成两方的互动,大家前边学了rabbitMQ,能够达成音信的传递;对于数据的共享,qq存款和储蓄的数据微信能够直接得到,这些数额是坐落内部存款和储蓄器中的,那大家怎么落到实处五个内部存款和储蓄器共享呢?我们要有三个中间商,中间商再运行三个独门的顺序,自身开荒一块内部存款和储蓄器,QQ和中间商创设二个socket,微信和中等商业营造1个socket,那样就得以落成了数码共享。这些中间商就是缓存。

Memcached安装:

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

wget http://memcached.org/latest
tar -zxvf latest
cd memcached-1.x.x
./configure && make && make test && sudo make install

ps:依赖包libevent
       yum install libevent-devel
       apt-get install libevent-dev

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 二:设置变量,并且不得不存活二秒钟

 

启动Memcached:

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实例都会爱护1个投机的连接池,能够向来建构三个连接池,然后作为参数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中1经想要知道多少个假名的2进制是不怎么,能够先用ord()转为ASCII 值,然后在用bin()转交换一下地方二进制,然后从后往前数7个人,不足补0,正是其一字母的2进制值

哪些时候会用呢?

今日头条和讯在线用户会有不少,如若做多少解析,想要看脚下有怎样用户在线,用数据库的频率是不高的。我们先看一下和命令bitcount,用来计数变量的二进制中有多少个一,如a:0b1一千0一,bitcount的结果正是叁

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

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

 

图片 47

那么数据库中种种用户的id是唯一的,从一方始自行抬高,参加大家有二亿的用户,有一亿在线,大家要总计这一亿用户到底是什么人在线,大家得以因而改二进制位来贯彻,即: (n二是二个新的变量)

进入有三个用户id为一千的用户登陆,大家设置:setbit n贰 一千 一,又登入了二个id为55伍的用户:setbit n二 55伍 一;用户id为5000的用户:setbit n2 四千 1;我们用bitcount来看望n2:

图片 48

表达在线用户有三个,那就贯彻了总计了在线用户人数,然后大家要看看到底是哪个人在线了,用户id是有点小编就取多少位,大家循环这些2进制的值就足以看看是应和的可怜人在线,例如

我们想看用户5五在不在线,大家用getbit:

图片 49

咱俩想看看用户555在不在线:

图片 50

咱俩有二亿用户,最多也就占用贰亿位,未有占多大空间,即使是用查看数据库的措施去看哪个人在线的话,那表的记录就越来越大,查询起来也不行慢。

 

strlen(name):再次回到name对应值的字节长度(四当中国字占二个字节)

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,自减数(整数)

 

只要大家不想总结全部用户在线的列表,你只想总结有微微用户在线,那只需求3个计数器,来三个加二个,同样也得以用redis落成,即便先来了三个用户,我们就一向:

 图片 51

再来1个用户:

图片 52

故此一平昔直接来:

图片 53

即使那些用户掉线了,就用decr

图片 54

也等于说使用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, 要追加的字符串

图片 55

 Hash操作,在redis中hash存在于内部存款和储蓄器中格式是这般的:

图片 56

hset(name, key, value)

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

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

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

 图片 57

设置二个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'})

图片 58

 

hget(name,key):

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

图片 59

获得info里面的name值和age值

 

hmget(name, keys, *args)

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

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

 图片 60

 

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

如获得info的享有键值:

图片 61

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

图片 62

 

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

图片 63

查阅那么些变量下的具有key,“属性”

 

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

图片 64

 

hexists(name, key):检查name对应的hash是或不是留存当前传遍的key,如若存在再次来到一,不存在重临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就起到贰个过滤的功力。

图片 65

其一意思正是在info第22中学从第0个key开端般配到以k伊始的键值对收取来

图片 66

其一意思乃是想要把带有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在内部存款和储蓄器中服从1个name对应1个List来储存

图片 67

lpush(name,values)

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

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

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

 图片 68

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

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

图片 69

我们能够看到我们新存的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,要插入的数据

 图片 70

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

 

r.lset(name, index, value):

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

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

 图片 71

正是做一个改换数据的操作,把第五个因素更动值

 

r.lrem(name, value, num):

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

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

 图片 72

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

 

lpop(name):

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

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

 图片 73

把names列表中的第一个成分移出了

 

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

 

lrange(name, start, end):

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

 图片 74

把names列表中装有的因素都抽出来就是0,-一.然后大家得以看来我们前边存进去的先抽出来,表明列表是先入后出

 图片 75

收获names中从第2个到第伍个因素,暗中同意是从0算起的,

ltrim(name, start, end):

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

 图片 76

移出除了第一第5个成分之外的有着的因素

 

rpoplpush(src, dst)

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

 图片 77

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

blpop(keys, timeout):

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

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

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

 图片 78

把names中的数据每一遍从左往右删除,假设names里面有成分就当下删除,担当就等候4s。

此处有2个用到:笔者把时光设置成40,然后在开发银行多少个redis客户端,然后在那40s之内自身在给names增添多少个新的要素,然后这边等待的客户端就立时把这么些值取出来了

图片 79图片 80

现行反革命也便是运转了多个经过,三个得以后列表中放入值,1个足以从列表中取值,有点像队列,想生产者消费者,因为除去的时候会回到删除的值就相当于抽出来数据

brpoplpush(src, dst, timeout=0)

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

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

 图片 81

哪怕把names二的成分移到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集合正是不容许再度的列表

图片 82

 

上海教室能够看看,小编往names中插入了四个值,不过在聚集中其实就唯有2个值,所以说集结是不容许再一次的列表

sadd(name,values):name对应的聚合中添新币素

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

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

图片 83

 

sdiffstore(dest, keys, *args):获取第1个name对应的集聚中且其余不再name对应的汇集,再讲其投入新的dest集结中

图片 84

 

把差集的结果存到会集n⑥中,

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

图片 85

 

sinterstore(dest, keys, *args):获取集合之间的插花,再讲其进入到dest对应的见面中

sismember(name, value):检查value是或不是是name对应的聚集的成员

smembers(name): 获取name对应的聚众的具有成员,集结不能用切片去取,因为它是严节的

图片 86

获取集结names三的全部值

 

smove(src, dst, value):将某些成员从一个汇集中活动到别的1个集中

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):同字符串的操作,用于增量迭代分批获取成分,制止内部存款和储蓄器消耗太大

 

不改变集中,在联谊的基本功上,为每成分排序;成分的排序须求依赖其它1个值来进行比较,所以,对于有序集中,每叁个成分有七个值,即:值和分数,分数专门用来做排序。

zadd(name, *args, **kwargs)

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

 图片 87

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

 

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)

 图片 88

图片 89

 

zrank(name, value): 

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

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

图片 90

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中的大4数据类型

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默许有十七个db,从0-一5 ,能够用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()

 

五.表露订阅

图片 91

那这些怎么落到实处的吧?

 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')

 

能够多少个公布新闻,通过同1个频段传给壹人:

图片 92

 

memcached -d -m 10    -u root -l 192.168.20.219 -p 12000 -c 256 -P /tmp/memcached.pi

参数说明:
    -d 是启动一个守护进程
    -m 是分配给Memcache使用的内存数量,单位是MB
    -u 是运行Memcache的用户
    -l 是监听的服务器IP地址
    -p 是设置Memcache监听的端口,最好是1024以上的端口
    -c 选项是最大运行的并发连接数,默认是1024,按照你服务器的负载量来设定
    -P 是设置保存Memcache的pid文件

Python安装Memcached模块:

python操作Memcached使用Python-memcached模块
下载安装:https://pypi.python.org/pypi/python-memcached

解压压缩包,然后在cmd命令下切换到安装包目录
执行 python setup.py install 安装

二、轻松连接

import memcache

mc = memcache.Client(["192.168.20.219:12000"],debug=True)
mc.set("foo","Hello,World")
ret = mc.get("foo")
print(ret)

# Hello,World

debug = True 表示运营出现错误时,展现错误消息,上线后移除该参数

3、集群

python-memcached模块原生帮忙集群操作,其规律是在内部存储器维护二个主机列表,且集群中主机的权重值和主机在列表中再现的次数成正比

  主机    权重
    1.1.1.1   1
    1.1.1.2   2
    1.1.1.3   1

那么在内存中主机列表为:
    host_list = ["1.1.1.1", "1.1.1.2", "1.1.1.2", "1.1.1.3", ]

只要用户依照要是要在内部存款和储蓄器中创建3个键值对(如:k一= "v一"),那么要实行一下步骤:

  • 依照算法将 k一 调换到2个数字
  • 将数字和主机列表长度求余数,得到三个值 N( 0 <= N < 列表长度 )
  • 在主机列表中根据第3步获得的值为索引获取主机,比如:host_list[N]
  • 连日 将第二步中获得的主机,将 k一 = "v壹" 放置在该服务器的内部存款和储蓄器中

代码落成如下:

mc = memcache.Client([('1.1.1.1:12000', 1), ('1.1.1.2:12000', 2), ('1.1.1.3:12000', 1)], debug=True)

mc.set('k1', 'v1')

4、Memcache操作

① add

增添一条键值对,若是已经存在的 key,重复推行add操作尤其

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
mc.add('k1', 'v1')

#MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'
#报错,对已经存在的key重复添加,失败!!!

②、replace

replace 修改有些key的值,纵然key不存在,则尤其

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
# 如果memcache中存在kkkk,则替换成功,否则异常
mc.replace('kkkk', '999')

#MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'

③、set 和 set_multi

set            设置多少个键值对,若是key不存在,则开创,要是key存在,则修改
set_multi   设置多少个键值对,借使key不存在,则开创,假使key存在,则修改

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)

mc.set('key0', 'lianzhilei')

mc.set_multi({'key1': 'val1', 'key2': 'val2'})

④、delete 和 delete_multi

delete             在Memcached中去除钦命的多少个键值对
delete_multi    在Memcached中删除钦定的七个键值对

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True)

mc.delete('key0')
mc.delete_multi(['key1', 'key2'])

⑤、get 和 get_multi

get            获取二个键值对
get_multi   获取多一个键值对

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True)

val = mc.get('key0')
item_dict = mc.get_multi(["key1", "key2", "key3"])

⑥、append 和 prepend

append    修改内定key的值,在该值 前面 追加内容
prepend   修改钦赐key的值,在该值 前边 插入内容

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
# k1 = "v1"

mc.append('k1', 'after')
# k1 = "v1after"

mc.prepend('k1', 'before')

⑦、decr 和 incr  

incr  自增,将Memcached中的某七个值扩展 N ( N默感到一 )
decr 自减,将Memcached中的某贰个值缩短 N ( N暗中同意为1 )

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
mc.set('k1', '777')

mc.incr('k1')
# k1 = 778

mc.incr('k1', 10)
# k1 = 788

mc.decr('k1')
# k1 = 787

mc.decr('k1', 10)
# k1 = 777

⑧、gets 和 cas

如超级市场商品剩余个数,假如改值保存在memcache中,product_count = 900
A用户刷新页面从memcache中读取到product_count = 900
B用户刷新页面从memcache中读取到product_count = 900

只要A、B用平衡购买商品

A用户修改商品剩余个数 product_count=899
B用户修改商品剩余个数 product_count=899

如此壹来缓存内的多寡便不在正确,四个用户购买商品后,商品剩余依然89九
举例运用python的set和get来操作以上进度,那么程序就能如上述所示情状!

若果想要防止此景况的发出,只要使用 gets 和 cas 就能够,如:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True, cache_cas=True)

v = mc.gets('product_count')
# ...
# 如果有人在gets之后和cas之前修改了product_count,那么,下面的设置将会执行失败,剖出异常,从而避免非正常数据的产生
mc.cas('product_count', "899")

Ps:本质上每便试行gets时,会从memcache中获得1个自增的数字,通过cas去修改gets的值时,会带走事先得到的自增值和memcache中的自增值进行比较,固然相等,则足以交到,即使不想等,那表示在gets和cas实行之间,又有别的人试行了gets(获取了缓冲的内定值), 如此一来有相当大概率出现畸形数据,则不容许修改

 

 

二、Redis

redis是一个key-value积存系统。和Memcached类似,它协助存款和储蓄的value类型相对越多,包蕴string(字符串)、list(链表)、set(集结)、zset(sorted set --有序会集)和hash(哈希类型)。这么些数据类型都扶助push/pop、add/remove及取交集并集和差集及更拉长的操作,而且那么些操作都以原子性的。在此基础上,redis援助种种差异方法的排序。与memcached同样,为了保证功能,数据皆以缓存在内部存款和储蓄器中。不相同的是redis会周期性的把创新的数目写入磁盘可能把修改操作写入追加的笔录文件,并且在此基础上贯彻了master-slave(主从)同步

一、安装和宗旨使用

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

起始服务端:

src/redis-server

启航客户端:

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

2、Python安装Redis模块

sudo pip install redis
or
sudo easy_install redis
or
源码安装

详见:https://github.com/WoLpH/redis-py

redis-py 的API的采纳能够分类为:

  • 一而再情势
  • 连接池
  • 操作管道
    • String 操作
    • Hash 操作
    • List 操作
    • Set 操作
    • Sort Set 操作
  • 管道
  • 透露订阅

三、简单连接

redis-py提供四个类Redis和StrictRedis用于落到实处Redis的命令,StrictRedis用于得以完成多数合法的指令,并动用官方的语法和下令,Redis是StrictRedis的子类,用于向后分外旧版本的redis-py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import redis

r = redis.Redis(host='192.168.20.219', port=6379)
r.set('foo', 'Hello,World')
print(r.get('foo'))

# b'Hello,World'

4、连接池

redis-py使用connection pool来保管对3个redis server的保有连接,制止每一遍建构、释放连接的付出。暗中认可,每一种Redis实例都会维护2个友好的连接池。能够一贯建构二个连接池,然后作为参数Redis,这样就足以兑现八个Redis实例共享二个连接池

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import redis

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

r = redis.Redis(connection_pool=pool)
r.set('foo', 'Hello,World')
print(r.get('foo'))

# b'Hello,World'

5、 String操作

redis中的String在在内部存款和储蓄器中依照叁个name对应三个value来存款和储蓄。如图:

图片 93

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

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

127.0.0.1:6379> set name lzl ex 2
OK
127.0.0.1:6379> get name
"lzl"
127.0.0.1:6379> get name
(nil)

② setnx(name, value)

设置值,只有name不存在时,执行设置操作(添加)

127.0.0.1:6379> setnx name lianzhilei
(integer) 0
127.0.0.1:6379> get name
"lzl"
127.0.0.1:6379> setnx name2 lianzhilei
(integer) 1
127.0.0.1:6379> get name2
"lianzhilei"

③ setex(name, value, time)

# 设置值
# 参数:
    # time,过期时间(数字秒 或 timedelta对象)

127.0.0.1:6379> setex age 2 18
OK
127.0.0.1:6379> get age
"18"
127.0.0.1:6379> get age
(nil)

④ psetex(name, time_ms, value)

# 设置值
# 参数:
    # time_ms,过期时间(数字毫秒 或 timedelta对象)

⑤ mset(*args, **kwargs)

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

127.0.0.1:6379[2]> mset name lzl age 18
OK
127.0.0.1:6379[2]> keys *
1) "age"
2) "name"

⑥ get(name)

#获取值

r.set("name","lzl")
print(r.get('name'))
# b'lzl'

⑦ mget(keys, *args)

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

127.0.0.1:6379[2]> mget name age
1) "lzl"
2) "18"

⑧ getset(name, value)

设置新值并获取原来的值

127.0.0.1:6379[2]> getset name eric
"lzl"
127.0.0.1:6379[2]> get name
"eric"

⑨ getrange(key, start, end)

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

127.0.0.1:6379[2]> getrange name 0 5
"lianzh"

⑩ 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"

# 扩展,转换二进制表示:

    # source = "连志雷"
    source = "foo"

    for i in source:
        num = ord(i)
        print(bin(num).replace('b',''))

    特别的,如果source是汉字 "连志雷"怎么办?
    答:对于utf-8,每一个汉字占 3 个字节,那么 "武沛齐" 则有 9个字节
       对于汉字,for循环时候会按照 字节 迭代,那么在迭代时,将每一个字节转换 十进制数,然后再将十进制数转换成二进制
        11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

127.0.0.1:6379[2]> set n1 foo
OK
127.0.0.1:6379[2]> setbit n1 7 1
(integer) 0
127.0.0.1:6379[2]> get n1
"goo"

setbit巨流弊的运用场景,想想怎么景况下会用到那些意义吗?超大型的选用平台,比如微博微博,作者想查看当前正在登入的用户,怎么着促成?当然你会想到,用户登入后在数据库上的用户音信上做个标识,然后count去总计做标识的用户一齐有稍许,so,当前用户查看消除;OK,好好,首先各样用户登入都要安装标识,假设当前用户几个亿,那么得存多少个亿的暗记位,一级占用库的开辟;现在就有3个强硬高效的不二秘籍,即总结当前在线用户,又显得在线用户ID,这便是接纳二进制位,什么意思呢?看下边包车型地铁代码就能够清楚了

统计在线用户数

127.0.0.1:6379[2]> setbit lineuser 1000 1      #1000表示用户id  
(integer) 0
127.0.0.1:6379[2]> setbit lineuser 55 1
(integer) 0
127.0.0.1:6379[2]> setbit lineuser 6000 1
(integer) 0
127.0.0.1:6379[2]> bitcount lineuser        #统计当前二进制位1的个数,即当前在线用户数
(integer) 3

bitcount总计二级制位中1的个数,setbit和bitcount合营使用,轻松解决当前在线用户数的主题材料,那还不是最厉害的,大家仍是可以接纳那几个总结当前在线的都有何人

查看用户ID有没有在线

127.0.0.1:6379[2]> getbit lineuser 1000        #查看id1000   1表示在线 0表示不在线
(integer) 1
127.0.0.1:6379[2]> getbit lineuser 100
(integer) 0

当然大家还足以经过for循环也许yield生成器打印出富有的在线用户ID,一字节=5位,那么十m=7000万位,即2个亿的在线用户也就拾m多的内部存款和储蓄器就可解决,优化就在个别之间

⑫ getbit(name, offset)

# 获取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对应值的字节长度(一个汉字3个字节)

127.0.0.1:6379[2]> get name
"lianzhilei"
127.0.0.1:6379[2]> strlen name
(integer) 10

⑯ incr(self, name, amount=1)

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

# 参数:
    # name,Redis的name
    # amount,自增数(必须是整数)

# 注:同incrby

127.0.0.1:6379[2]> incr login_users     #自增
(integer) 1
127.0.0.1:6379[2]> incr login_users 
(integer) 2
127.0.0.1:6379[2]> incr login_users 
(integer) 3

⑰ 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,自减数(整数)

127.0.0.1:6379[2]> decr login_users     #自减
(integer) 2
127.0.0.1:6379[2]> decr login_users
(integer) 1
127.0.0.1:6379[2]> decr login_users
(integer) 0

⑲ append(key, value)

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

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

127.0.0.1:6379[2]> append name jjjj
(integer) 14
127.0.0.1:6379[2]> get name
"lianzhileijjjj"

 

6、Hash操作

redis中Hash在内部存款和储蓄器中的存款和储蓄格式如下图:

图片 94

① hset(name, key, value)

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

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

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


127.0.0.1:6379[3]> hset class14 name lzl
(integer) 1
127.0.0.1:6379[3]> hset class14 age 18
(integer) 1
127.0.0.1:6379[3]> hset class14 id 10001
(integer) 1
127.0.0.1:6379[3]> hgetall class14
1) "name"
2) "lzl"
3) "age"
4) "18"
5) "id"
6) "10001"
127.0.0.1:6379[3]> hget class14 name
"lzl"
127.0.0.1:6379[3]> hkeys class14
1) "name"
2) "age"
3) "id"
127.0.0.1:6379[3]> hvals class14
1) "lzl"
2) "18"
3) "10001"

② hmset(name, mapping)

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

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

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

127.0.0.1:6379[3]> hmset info k1 1 k2 2
OK
127.0.0.1:6379[3]> hmget info k1 k2
1) "1"
2) "2"

③ hget(name,key)

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

④ hmget(name, keys, *args)

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

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

# 如:
    # r.mget('xx', ['k1', 'k2'])
    # 或
    # print r.hmget('xx', 'k1', 'k2')

127.0.0.1:6379[3]> hmset info k1 1 k2 2
OK
127.0.0.1:6379[3]> hmget info k1 k2
1) "1"
2) "2"

⑤ hgetall(name)

获取name对应hash的所有键值

⑥ hlen(name)

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

127.0.0.1:6379[3]> hlen info 
(integer) 2

⑦ hkeys(name)

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

⑧ hvals(name)

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

⑨ hexists(name, key)

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

127.0.0.1:6379[3]> hexists info k1
(integer) 1
127.0.0.1:6379[3]> hexists info k3
(integer) 0

⑩ hdel(name,*keys)

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

⑪ hincrby(name, key, amount=1)

# 自增name对应的hash中的指定key的值,不存在则创建key=amount
# 参数:
    # name,redis中的name
    # key, hash对应的key
    # amount,自增数(整数)

127.0.0.1:6379[3]> hincrby info k3 1
(integer) 1
127.0.0.1:6379[3]> hincrby info k3 1
(integer) 2
127.0.0.1:6379[3]> hincrby info k3 1
(integer) 3

⑫ 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, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    # ...
    # 直到返回值cursor的值为0时,表示数据已经通过分片获取完毕

127.0.0.1:6379[3]> hscan info 0 match k*
1) "0"
2) 1) "k1"
   2) "1"
   3) "k2"
   4) "2"
   5) "k3"
   6) "3"

⑭ 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

 

7、List操作

redis中的List在在内部存款和储蓄器中遵照三个name对应2个List来囤积。如图:

图片 95

① lpush(name,values)

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

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

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

127.0.0.1:6379[3]> lpush names lzl alex wupeiqi 
(integer) 3
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "alex"
3) "lzl"

② lpushx(name,value)

# 在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边

# 更多:
    # rpushx(name, value) 表示从右向左操作

③ llen(name)

name对应的list元素的个数

127.0.0.1:6379[3]> llen names
(integer) 3

④ linsert(name, where, refvalue, value))

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

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

127.0.0.1:6379[3]> linsert names BEFORE alex befor
(integer) 4
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "befor"
3) "alex"
4) "lzl"

⑤ lset(name, index, value)

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

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

127.0.0.1:6379[3]> lset names 3 LianZhiLei
OK
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "befor"
3) "alex"
4) "LianZhiLei"

⑥ lrem(name, value, num)

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

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

127.0.0.1:6379[3]> lrem names 1 befor
(integer) 1
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "alex"
3) "LianZhiLei"

⑦ lpop(name)

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

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

127.0.0.1:6379[3]> lpop names
"wupeiqi"

⑧ 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,索引结束位置

127.0.0.1:6379[3]> LRANGE names 0 -1
1) "eric"
2) "wupeiqi"
3) "alex"
4) "LianZhiLei"
127.0.0.1:6379[3]> ltrim names 1 2
OK
127.0.0.1:6379[3]> LRANGE names 0 -1
1) "wupeiqi"
2) "alex"

⑪ rpoplpush(src, dst)

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

127.0.0.1:6379[3]> rpush names2 LZL
(integer) 1
127.0.0.1:6379[3]> RPOPLPUSH names names2
"alex"
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
127.0.0.1:6379[3]> lrange names2 0 -1
1) "alex"
2) "LZL"

⑫ 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

 

8、Set操作

Set集结便是不一致意再度的列表

① sadd(name,values)

# name对应的集合中添加元素

127.0.0.1:6379[3]> sadd names alex alex lzl lzl jack 
(integer) 3
127.0.0.1:6379[3]> smembers names
1) "jack"
2) "alex"
3) "lzl"

② scard(name)

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

127.0.0.1:6379[3]> scard names
(integer) 3

③ sdiff(keys, *args)

# 在第一个name对应的集合中且不在其他name对应的集合的元素集合(差级)

127.0.0.1:6379[3]> sadd names2 eric lzl wupeiqi
(integer) 3
127.0.0.1:6379[3]> sdiff names names2
1) "alex"
2) "jack"

④ sdiffstore(dest, keys, *args)

# 获取name1集合里有但是name2集合里没有的元素,然后把元素添加到dest对应的集合中

127.0.0.1:6379[3]> SMEMBERS names
1) "jack"
2) "alex"
3) "lzl"
127.0.0.1:6379[3]> SMEMBERS names2
1) "wupeiqi"
2) "lzl"
3) "eric"
127.0.0.1:6379[3]> SDIFFSTORE dest names names2
(integer) 2
127.0.0.1:6379[3]> SMEMBERS dest
1) "alex"
2) "jack"

⑤ sinter(keys, *args)

# 获取多个name集合中的交集

127.0.0.1:6379[3]> SINTER names names2 
1) "lzl"

⑥ sinterstore(dest, keys, *args)

# 获取多个name对应集合的交集,再讲其加入到dest对应的集合中

⑦ sismember(name, value)

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

127.0.0.1:6379[3]> SISMEMBER names lzl
(integer) 1

⑧ 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)

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

127.0.0.1:6379[3]> sscan names 0 match l*
1) "0"
2) 1) "lzl"

 

 

玖、有序集中

在集结的功底上,为每成分排序;成分的排序需求基于此外三个值来拓展比较,所以,对于有序聚焦,每一个要素有七个值,即:值和分数,分数专门用来做排序

① zadd(name, *args, **kwargs)

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

127.0.0.1:6379[4]> zadd z1 10 lzl 5 alex 8 jack  11 lzl
(integer) 3
127.0.0.1:6379[4]> ZRANGE z1 0 -1
1) "alex"
2) "jack"
3) "lzl"

#按分值排序并去重

② zcard(name)

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

③ zcount(name, min, max)

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

127.0.0.1:6379[4]> ZCOUNT z1 6 9
(integer) 1

④ zincrby(name, value, amount)

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

⑤ 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)

127.0.0.1:6379[4]> ZRANGE z1 0 -1 withscores
1) "alex"
2) "5"
3) "jack"
4) "8"
5) "lzl"
6) "11"

⑥ zrank(name, value)

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

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

127.0.0.1:6379[4]> ZRANK z1 lzl
(integer) 2

#排名第二

⑦ 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,用来对分数进行操作

 

10、其余常用操作

① 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下

⑦ randomkey()

# 随机获取一个redis的name(不删除)

⑧ type(name)

# 获取name对应值的类型

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

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

 

11、管道

redis-py私下认可在实践每趟请求都会成立(连接池申请连接)和断开(归还连接池)三遍延续操作,假诺想要在二回呼吁中内定四个指令,则能够利用pipline完成1遍呼吁钦定多少个指令,并且默许景况下3回pipline 是原子性操作

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import redis

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

 

12、宣布订阅
图片 96

redishelper:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import redis

class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='192.168.20.219')
        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

订阅者:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

from redishelper import RedisHelper

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

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

发布者:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

from redishelper import RedisHelper

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

越来越多参见:

  

 

TAG标签:
版权声明:本文由澳门新葡8455手机版发布于计算机编程,转载请注明出处:读书笔记,数据库操作Memcache