您的位置:时时app平台注册网站 > 编程知识 > Python开发【十一章】:数据库操作Memcache、Redis【

Python开发【十一章】:数据库操作Memcache、Redis【

2019-11-21 02:18

比方说一个是QQ,一个是微信,我们想要实现二者的交互,我们之前学了rabbitMQ,可以实现消息的传递;对于数据的共享,qq存储的数据微信可以直接拿到,这个数据是放在内存中的,那我们怎么实现两个内存共享呢?我们要有一个中间商,中间商再启动一个独立的程序,自己开辟一块内存,QQ和中间商建立一个socket,微信和中间商业建立一个socket,这样就实现了数据共享。这个中间商就是缓存。

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

from redishelper import RedisHelper

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

前言:

⑬ sunion(keys, *args)

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:0b1100001,bitcount的结果就是3

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

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

 

时时app平台注册网站 1

那么数据库中每个用户的id是唯一的,从1开始自动累加,加入我们有2亿的用户,有1亿在线,我们要统计这1亿用户到底是谁在线,我们可以通过改二进制位来实现,即: (n2是一个新的变量)

加入有一个用户id为1000的用户登录,我们设置:setbit n2 1000 1 ,又登录了一个id为555的用户:setbit n2 555 1;用户id为6000的用户:setbit n2 6000 1;我们用bitcount来看看n2:

时时app平台注册网站 2

说明在线用户有3个,这就实现了统计了在线用户人数,然后我们要看看究竟是谁在线了,用户id是多少我就取多少位,我们循环这个二进制的值就可以看到是对应的那个人在线,比如

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

时时app平台注册网站 3

我们想看看用户555在不在线:

时时app平台注册网站 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实现,如果先来了一个用户,我们就直接:

 时时app平台注册网站 5

再来一个用户:

时时app平台注册网站 6

所以一直来一直来:

时时app平台注册网站 7

如果这个用户掉线了,就用decr

时时app平台注册网站 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, 要追加的字符串

时时app平台注册网站 9

 Hash操作,在redis中hash存在于内存中格式是这样的:

时时app平台注册网站 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时则创建(相当于添加)

 时时app平台注册网站 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'})

时时app平台注册网站 12

 

hget(name,key):

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

时时app平台注册网站 13

获得info里面的name值和age值

 

hmget(name, keys, *args)

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

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

 时时app平台注册网站 14

 

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

如获取info的所有键值:

时时app平台注册网站 15

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

时时app平台注册网站 16

 

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

时时app平台注册网站 17

查看这个变量下的所有key,“属性”

 

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

时时app平台注册网站 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就起到一个过滤的作用。

时时app平台注册网站 19

这个意思就是在info2中从第0个key开始匹配到以k开头的键值对取出来

时时app平台注册网站 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来存储

时时app平台注册网站 21

lpush(name,values)

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

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

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

 时时app平台注册网站 22

设置names列表,里面有3个元素,放在列表的最左边

有lpush,就有rpush,就是存元素是放在列表的右端:rpush names xixi haha hehe

时时app平台注册网站 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,要插入的数据

 时时app平台注册网站 24

在names中往xiaoming前面插入meimei这个新的元素

 

r.lset(name, index, value):

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

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

 时时app平台注册网站 25

就是做一个修改数据的操作,把第6个元素更改值

 

r.lrem(name, value, num):

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

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

 时时app平台注册网站 26

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

 

lpop(name):

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

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

 时时app平台注册网站 27

把names列表中的第一个元素移出了

 

lindex(name, index):在name对应的列表中根据索引获取列表元素

 

lrange(name, start, end):

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

 时时app平台注册网站 28

把names列表中所有的元素都取出来就是0,-1.然后我们可以看到我们后面存进去的先取出来,说明列表是先入后出

 时时app平台注册网站 29

获取names中从第二个到第四个元素,默认是从0算起的,

ltrim(name, start, end):

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

 时时app平台注册网站 30

移出除了第2第三个元素之外的所有的元素

 

rpoplpush(src, dst)

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

 时时app平台注册网站 31

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

blpop(keys, timeout):

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

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

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

 时时app平台注册网站 32

把names中的数据每次从左往右删除,如果names里面有元素就立刻删除,负责就等待4s。

这里有一个应用:我把时间设置成40,然后在启动一个redis客户端,然后在这40s之内我在给names添加一个新的元素,然后那边等待的客户端就立刻把这个值取出来了

时时app平台注册网站 33时时app平台注册网站 34

现在相当于启动了两个进程,一个可以往列表中放入值,一个可以从列表中取值,有点像队列,想生产者消费者,因为删除的时候会返回删除的值就相当于取出来数据

brpoplpush(src, dst, timeout=0)

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

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

 时时app平台注册网站 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集合就是不允许重复的列表

时时app平台注册网站 36

 

上图可以看到,我往names中插入了6个值,但是在集合中实际就只有3个值,所以说集合是不允许重复的列表

sadd(name,values):name对应的集合中添加元素

scard(name): 获取name对应的集合中元素的个数

sdiff(keys, *args):在第一个name集合中且不再其他name对应的集合中的元素集合(差集:不含B集合元素的所有A元素)

时时app平台注册网站 37

 

sdiffstore(dest, keys, *args):获取第一个name对应的集合中且其他不再name对应的集合,再讲其加入新的dest集合中

时时app平台注册网站 38

 

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

sinter(keys, *args):(数学里的交集)

时时app平台注册网站 39

 

sinterstore(dest, keys, *args):获取集合之间的交集,再讲其加入到dest对应的集合中

sismember(name, value):检查value是否是name对应的集合的成员

smembers(name): 获取name对应的集合的所有成员,集合不能用切块去取,因为它是无序的

时时app平台注册网站 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)

 时时app平台注册网站 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)

 时时app平台注册网站 42

时时app平台注册网站 43

 

zrank(name, value): 

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

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

时时app平台注册网站 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默认有16个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.发布订阅

时时app平台注册网站 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')

 

可以多个发布信息,通过同一个频道传给一个人:

时时app平台注册网站 46

 

① sadd(name,values)

大家都听过缓存,缓存是干啥的呢?我们可以和json和pickle来说,两个程序之间实现信息交互,可以通过在A程序中把数据改成json ,然后传给B程序,通过文件这个介质。文件这个效率很低。

 

缓存

① lpush(name,values)

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秒钟

 

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

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

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

# 在第一个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"
# 从集合的右侧(尾部)移除一个成员,并将其返回

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

# 在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"

⑲ append(key, value)

⑭ bitop(operation, dest, *keys)

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

 

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

import memcache

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

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

mc.prepend('k1', 'before')
# 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (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)

⑦ randomkey()

# 获取name对应值的类型

④、delete 和 delete_multi

⑧ type(name)

⑥ get(name)

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

⑤ mset(*args, **kwargs)

Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程(daemon )是用C写的,但是客户端可以用任何语言来编写,并通过memcached协议与守护进程通信。

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

# 参数:
    # name,redis中的name
    # key, hash对应的key
    # amount,自增数(浮点数)

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

② setnx(name, value)

11、管道

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

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

⑦ sismember(name, value)

⑧、gets 和 cas

# 同字符串相似,相较于字符串新增score_cast_func,用来对分数进行操作
#!/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()

4、Memcache操作

⑨ zremrangebyrank(name, min, max)

⑥ zrank(name, value)

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

⑤ hgetall(name)

# 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"
# 删除name对应的有序集合中值是values的成员

# 如:zrem('zz', ['s1', 's2'])
# 自减 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
# 设置值
# 参数:
    # 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)

12、发布订阅
时时app平台注册网站 47

启动Memcached:

⑫ blpop(keys, timeout)

3、简单连接

⑬ brpoplpush(src, dst, timeout=0)

⑫ hincrbyfloat(name, key, amount=1.0)

⑭ 自定义增量迭代

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

  

② exists(name)

⑦ lpop(name)

# 根据分数范围删除
# 将多个列表排列,按照从左到右去pop对应列表的元素

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

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

9、有序集合

set            设置一个键值对,如果key不存在,则创建,如果key存在,则修改
set_multi   设置多个键值对,如果key不存在,则创建,如果key存在,则修改

② scard(name)

⑤ lset(name, index, value)

# 检测redis的name是否存在

⑦ hkeys(name)

# 从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 参数:
    # 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"

④ zincrby(name, value, amount)

# 根据排行范围删除

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

时时app平台注册网站 48

redis中Hash在内存中的存储格式如下图:

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

 

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

②、replace

# 在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"
获取name对应hash的所有键值

redis安装:

发布者:

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

② zcard(name)

#!/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"])

Ps:本质上每次执行gets时,会从memcache中获取一个自增的数字,通过cas去修改gets的值时,会携带之前获取的自增值和memcache中的自增值进行比较,如果相等,则可以提交,如果不想等,那表示在gets和cas执行之间,又有其他人执行了gets(获取了缓冲的指定值), 如此一来有可能出现非正常数据,则不允许修改

python-memcached模块原生支持集群操作,其原理是在内存维护一个主机列表,且集群中主机的权重值和主机在列表中重复出现的次数成正比

③ hget(name,key)

如果A、B用户均购买商品

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

⑬ zinterstore(dest, keys, aggregate=None)

查看用户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
# 在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"

#按分值排序并去重
# 获取name对应的hash中所有的value的值

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

append    修改指定key的值,在该值 后面 追加内容
prepend   修改指定key的值,在该值 前面 插入内容

⑩ ltrim(name, start, end)

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

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
# 获取多一个name对应的集合的并集,并将结果保存到dest对应的集合中

⑧ lindex(name, index)

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
# 同字符串的操作,用于增量迭代分批获取元素,避免内存消耗太大

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

③ setex(name, value, time)

# 根据值返回删除

⑪ srandmember(name, numbers)

⑯ incr(self, name, amount=1)

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

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

setbit巨流弊的应用场景,想想什么情况下会用到这个功能呢?超大型的应用平台,比如新浪微博,我想查看当前正在登陆的用户,如何实现?当然你会想到,用户登陆后在数据库上的用户信息上做个标记,然后count去统计做标记的用户一共有多少,so,当前用户查看迎刃而解;OK,好好,首先每个用户登录都要设置标记,如果当前用户几个亿,那么得存几个亿的标记位,超级占用库的开销;现在就有一个无敌高效的办法,即统计当前在线用户,又显示在线用户ID,那就是利用二进制位,什么意思呢?看下面的代码就能明白了

#!/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)

10、其他常用操作

#!/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")

⑤ sinter(keys, *args)

1、安装和基本使用

# 获取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"
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

⑱ decr(self, name, amount=1)

② lpushx(name,value)

#!/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'

启动服务端:

2、Python安装Redis模块

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

⑬ hscan(name, cursor=0, match=None, count=None)

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

 

如果想要避免此情况的发生,只要使用 gets 和 cas 即可,如:

3、集群

④ sdiffstore(dest, keys, *args)

⑫ zscore(name, value)

 

⑭ hscan_iter(name, match=None, count=None)

⑧ zrem(name, values)

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

# 由于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

⑦ mget(keys, *args)

#获取值

r.set("name","lzl")
print(r.get('name'))
# b'lzl'
# 获取name对应的值的二进制表示中的某位的值 (0或1)
# 在name对应的集合中删除某些值
统计在线用户数

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

⑥、append 和 prepend

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

redis中的List在在内存中按照一个name对应一个List来存储。如图:

⑪ hincrby(name, key, amount=1)

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

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

⑩ hdel(name,*keys)

当然我们还可以通过for循环或者yield生成器打印出所有的在线用户ID,1字节=8位,那么10m=8000万位,即一个亿的在线用户也就10m多的内存就可搞定,优化就在点滴之间

bitcount统计二级制位中1的个数,setbit和bitcount配合使用,轻松解决当前在线用户数的问题,这还不是最厉害的,我们还能利用这个统计当前在线的都有谁

  • 根据算法将 k1 转换成一个数字
  • 将数字和主机列表长度求余数,得到一个值 N( 0 <= N < 列表长度 )
  • 在主机列表中根据 第2步得到的值为索引获取主机,例如:host_list[N]
  • 连接 将第3步中获取的主机,将 k1 = "v1" 放置在该服务器的内存中
设置新值并获取原来的值

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

添加一条键值对,如果已经存在的 key,重复执行add操作异常

⑮ strlen(name)

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文件
# 将某个成员从一个集合中移动到另外一个集合

 

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

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

③ keys(pattern='*')

在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)
#!/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'

③ llen(name)

③、set 和 set_multi

6、Hash操作

⑭ zunionstore(dest, keys, aggregate=None)

代码实现如下:

# 设置值
# 参数:
    # time_ms,过期时间(数字毫秒 或 timedelta对象)
# 同字符串操作,用于增量迭代获取key

① hset(name, key, value)

⑦、decr 和 incr  

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

详见:https://github.com/WoLpH/redis-py
#!/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'})
# 在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"

④ psetex(name, time_ms, value)

#!/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
# 获取name对应的值的二进制表示中 1 的个数
# 参数:
    # key,Redis的name
    # start,位起始位置
    # end,位结束位置
# 在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"

 

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

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

⑩ zremrangebyscore(name, min, max)

⑪ setbit(name, offset, value)

redis中的String在在内存中按照一个name对应一个value来存储。如图:

# 自增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

启动客户端:

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

⑥ hlen(name)

name对应的list元素的个数

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

incr  自增,将Memcached中的某一个值增加 N ( N默认为1 )
decr 自减,将Memcached中的某一个值减少 N ( N默认为1 )

⑰ incrbyfloat(self, name, amount=1.0)

⑤ zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)

⑩ spop(name)

8、Set操作

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

Python安装Memcached模块:

4、连接池

⑨ lrange(name, start, end)

# 对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"
# 获取name对应的有序集合中分数 在 [min,max] 之间的个数

127.0.0.1:6379[4]> ZCOUNT z1 6 9
(integer) 1
# 获取多个name集合中的交集

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

③ zcount(name, min, max)

 

2、简单连接

#!/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'])

⑥ lrem(name, value, num)

设置值,只有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"
src/redis-server
# 获取name对应的hash中所有的key的值
# 按照索引范围获取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"
# 为某个redis的某个name设置超时时间
# 在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"
# 检查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

⑧ hvals(name)

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

⑦ zrangebylex(name, min, max, start=None, num=None)

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

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

# 如:
    # for item in r.hscan_iter('xx'):
    #     print item
# 在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"
# 自增 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

replace 修改某个key的值,如果key不存在,则异常

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

③ sdiff(keys, *args)

⑫ getbit(name, offset)

# 在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"

⑭ sunionstore(dest,keys, *args)

⑤ rename(src, dst)

⑤、get 和 get_multi

⑧ smembers(name)

④ expire(name ,time)

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

127.0.0.1:6379[2]> mget name age
1) "lzl"
2) "18"
# 在name对应的hash中获取根据key获取value
# 返回name对应值的字节长度(一个汉字3个字节)

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

debug = True 表示运行出现错误时,显示错误信息,上线后移除该参数

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

④ hmget(name, keys, *args)

# 对redis的name重命名为
# 获取name对应的hash中键值对的个数

127.0.0.1:6379[3]> hlen info 
(integer) 2
# 在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边

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

⑥ move(name, db))

⑩ setrange(name, offset, value)

二、Redis

⑪ rpoplpush(src, dst)

Memcached安装:

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

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

① add

  主机    权重
    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", ]

⑫ srem(name, values)

时时app平台注册网站 49

如果用户根据如果要在内存中创建一个键值对(如:k1 = "v1"),那么要执行一下步骤:

# 根据模型获取redis的name

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

⑨ getrange(key, start, end)

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

#!/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重复添加,失败!!!

redishelper:

 

⑧ getset(name, value)

5、 String操作

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

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

更多参见:

 

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

① delete(*names)

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

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

  • 连接方式
  • 连接池
  • 操作管道
    • String 操作
    • Hash 操作
    • List 操作
    • Set 操作
    • Sort Set 操作
  • 管道
  • 发布订阅
#!/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'

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

如此一来缓存内的数据便不在正确,两个用户购买商品后,商品剩余还是 899
如果使用python的set和get来操作以上过程,那么程序就会如上述所示情况!

⑪ zremrangebylex(name, min, max)

# 根据删除redis中的任意数据类型
# 获取某个值在 name对应的有序集合中的排行(从 0 开始)

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

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

#排名第二

7、List操作

一、Memcached

⑥ sinterstore(dest, keys, *args)

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

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

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

批量设置值
如:
    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"
# 增量式迭代获取,对于数据大的数据非常有用,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"

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

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
# 在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素

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

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

⑨ hexists(name, key)

 

② hmset(name, mapping)

时时app平台注册网站 50

⑨ smove(src, dst, 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"
# 获取多个值,并将值做位运算,将最后的结果保存至新的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 对应的值中

delete             在Memcached中删除指定的一个键值对
delete_multi    在Memcached中删除指定的多个键值对

本文由时时app平台注册网站发布于编程知识,转载请注明出处:Python开发【十一章】:数据库操作Memcache、Redis【

关键词: