一、redis基本安装和简单使用

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

  Redis 是一个高性能的key-value数据库。 redis的出现,很大程度补偿了memcached这类key/value存储的不足,在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java,C/C++,C#,PHP,JavaScript,Perl,Object-C,Python,Ruby,Erlang等客户端,使用很方便。[1] 
Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步,从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制,使得从数据库在任何地方同步树时,可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

  1、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
makemake install

  1)启动服务端:  

src/redis-server

  2)启动客户端:  

root@lcj-virtual-machine:/redis-3.0.6/src# ./redis-cli
Could not connect to Redis at 127.0.0.1:6379: Connection refused
not connected> set name lcj
OK
127.0.0.1:6379> get name
"lcj"
127.0.0.1:6379>

  2、Python操作redis

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

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

 API使用

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

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

  1)操作模式

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

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
f1 = redis.Redis(host="192.168.1.104", port=6379,)
f1.set('foo','lcj') #向redis插入数据lcj
print(f1.get('foo')) #获取redis中foo值
#b'lcj'

  2)连接池

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

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口并创建链接池
pool = redis.ConnectionPool(host="192.168.1.104", port=6379,)
ret = redis.Redis(connection_pool=pool)
ret.set('name','xiaoluo')  #给连接池插入数据
print(ret.get('name')) #获取数据
#b'xiaoluo'

  3)操作

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

  

  set方法常用格式: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)

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
f1 = redis.Redis(host="192.168.1.104", port=6379,)
# f1.set('foo','lcj') #向redis插入数据lcj
# print(f1.get('foo')) #获取redis中foo值
#输出:b'lcj'
#setnx:只有单foo不存在时,才会执行设置操作,如果foo存在,setnx则不会进行设置
f1.setnx('fol','xiaoluo')
print(f1.get('fol'))
#输出:b'xiaoluo'

  setnx(name,value,time)

  参数time:表示过期时间,单位秒或timedeta对象,超过1秒后设置的数据则不存在

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
f1 = redis.Redis(host="192.168.1.104", port=6379,)
#setnx:只有单foo不存在时,才会执行设置,如果foo存在,setnx则不会记性设置
f1.setnx('fol','xiaoluo',1)  #1表示过期时间:指1秒后,设置的值存在
print(f1.get('fol'))

  psetex(name,time_ms,value)

  time_ms:过期时间,单位为毫秒或timedelta对象   

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
f1 = redis.Redis(host="192.168.1.104", port=6379,)
f1.psetex('ff',1,'xiaoluo',)  #1:过期时间毫秒
print(f1.get('ff'))
#b'xiaoluo'

  getset(name, value)

  getset:对存在key进行重新设置薪资并获取原来的值

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
f1 = redis.Redis(host="192.168.1.104", port=6379,)
f1.setnx('fol','xiaoluo',)  #1
print(f1.get('fol'))
f1.getset('fol','alex') #getset:对存在fol值进行重新赋值
print(f1.get('fol'))
# b'xiaoluo'
# b'alex'

  mset(*args,**kwargs)

  mset:批量设值(值可以列表形式存在)

  mget(keys, *args)

  格式:

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

  mget:批量获取值 

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
f1 = redis.Redis(host="192.168.1.104", port=6379,)
f1.mset(k1='lcj',k2='xiaoluo',k3='alex') #mset:批量设置值
print(f1.mget(['k1','k2','k3']))  #批量获取值
# [b'lcj', b'xiaoluo', b'alex']

  get(name)

获取值

  getset(name, value)    

设置新值并获取原来的值

  getrange(key,start,end)  

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
k1 = redis.Redis(host="192.168.1.104", port=6379,)
k1.set('lcj','236')
print(k1.get('lcj'))
print(k1.getrange('lcj',0,1))  #getrange:(key,start,end)根据索引获取值
# b'236'
# b'23'
# 获取子序列(根据字节获取,非字符)
# 参数:
    # name,Redis 的 name
    # start,起始位置(字节)
    # end,结束位置(字节)

  setrange(name, offset, value)   

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
k1 = redis.Redis(host="192.168.1.104", port=6379,)
k1.set('lcj','236')
print(k1.get('lcj'))
k1.setrange('lcj',0,8)
print(k1.get('lcj',))
# b'236'
# b'836'
# 修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
# 参数:
    # 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循环时候会按照 字节 迭代,那么在迭代时,将每一个字节转换 十进制数,然后再将十进制数转换成二进制  
# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
k1 = redis.Redis(host="192.168.1.104", port=6379,)
k1.set('lcj','236') #设置key值
print(k1.get('lcj')) #输出key值
k1.setbit('lcj',0,1)  #
print(k1.get('lcj'))
# b'236'
# b'\xb236'

  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个字节)

  incr(self, name, amount=1)

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
k1 = redis.Redis(host="192.168.1.104", port=6379,)
k1.set('lcj','236',)  #创建key值
print(k1.get('lcj'))   #输出key值
k1.incr('lcj',10)  #incr:自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
print(k1.get('lcj'))
# b'236'
# b'246'
# 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
 # 参数:
    # name,Redis的name
    # amount,自增数(必须是整数)
# 注:同incrby

  incrbyfloat(self, name, amount=1.0)  

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

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

  decr(self, name, amount=1)  

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
k1 = redis.Redis(host="192.168.1.104", port=6379,)
k1.set('lcj','236',)  #创建key值
print(k1.get('lcj'))   #输出key值
k1.decr('lcj',5)  #decr:自减 name对应的值,当name不存在时,则创建name=amount,否则,自减。
print(k1.get('lcj'))
# b'236'
# b'231'
# 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。
# 参数:
    # name,Redis的name
    # amount,自减数(整数)

  append(key, value)  

# !/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
import redis
#链接主机IP和端口
k1 = redis.Redis(host="192.168.1.104", port=6379,)
k1.set('lcj','236',)  #创建key值
print(k1.get('lcj'))   #输出key值
k1.decr('lcj',5)  #decr:自减 name对应的值,当name不存在时,则创建name=amount,否则,自减。
print(k1.get('lcj'))
k1.append('lcj',9999)  #append:在key值后面追加9999
print(k1.get('lcj'))
# b'236'
# b'231'
# b'2319999'
# 在redis name对应的值后面追加内容

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

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

  hset(name, key, value)  

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

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

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

  hmset(name, mapping)

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

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

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

  hget(name,key)

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

  hmget(name, keys, *args)

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

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

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

  hgetall(name)

获取name对应hash的所有键值

  hlen(name)

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

  hkeys(name)

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

  hvals(name)

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

  hexists(name, key)

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

  hdel(name,*keys)

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

  hincrby(name, key, amount=1)

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

  hincrbyfloat(name, key, amount=1.0)

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

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

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

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

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

# 参数:
    # name,redis的name
    # cursor,游标(基于游标分批取获取数据)
    # match,匹配指定key,默认None 表示所有的key
    # count,每次分片最少获取个数,默认None表示采用Redis的默认分片个数

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

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

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

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

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

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

  

  lpush(name,values)

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

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

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

  lpushx(name,value)

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

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

  llen(name)

# name对应的list元素的个数

  linsert(name, where, refvalue, value))

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

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

  r.lset(name, index, value)

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

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

  r.lrem(name, value, num)

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

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

  lpop(name)

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

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

  lindex(name, index)

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

  lrange(name, start, end)

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

  ltrim(name, start, end)

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

  rpoplpush(src, dst)

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

  blpop(keys, timeout)

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

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

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

  brpoplpush(src, dst, timeout=0)

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

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

  自定义增量迭代:

# 由于redis类库中没有提供对列表元素的增量迭代,如果想要循环name对应的列表的所有元素,那么就需要:
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是,如果列表非常大,那么就有可能在第一步时就将程序的内容撑爆,所有有必要自定义一个增量迭代的功能:

def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name,即:迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in xrange(list_count):
        yield r.lindex(name, index)

# 使用
for item in list_iter('pp'):
    print item

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

  sadd(name,values)

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

  scard(name)

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

  sdiff(keys, *args)

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

  sdiffstore(dest, keys, *args)

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

  sinter(keys, *args)

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

  sinterstore(dest, keys, *args)

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

  sismember(name, value)

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

  smembers(name)

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

  smove(src, dst, value)

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

  spop(name)

# 从集合的右侧(尾部)移除一个成员,并将其返回

  srandmember(name, numbers)

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

  srem(name, values)

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

  sunion(keys, *args)

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

  sunionstore(dest,keys, *args)

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

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

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

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

  zadd(name, *args, **kwargs)

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

  zcard(name)

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

  zcount(name, min, max)

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

  zincrby(name, value, amount)

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

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

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

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

# 更多:
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)

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

  zrank(name, value)

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

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

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

# 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (lexicographical ordering)来进行排序,而这个命令则可以返回给定的有序集合键 key 中, 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比(byte-by-byte compare), 并按照从低到高的顺序, 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话, 那么命令会认为较长的字符串比较短的字符串要大

# 参数:
    # name,redis的name
    # min,左区间(值)。 + 表示正无限; - 表示负无限; ( 表示开区间; [ 则表示闭区间
    # min,右区间(值)
    # start,对结果进行分片处理,索引位置
    # num,对结果进行分片处理,索引后面的num个元素

# 如:
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为:['aa', 'ba', 'ca']

# 更多:
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

  zrem(name, values)

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

# 如:zrem('zz', ['s1', 's2'])

  zremrangebyrank(name, min, max)

# 根据排行范围删除

  zremrangebyscore(name, min, max)

# 根据分数范围删除

  zremrangebylex(name, min, max)

# 根据值返回删除

  zscore(name, value)

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

  zinterstore(dest, keys, aggregate=None) 

# 获取两个有序集合的交集,如果遇到相同值不同分数,则按照aggregate进行操作
# 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下

  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 是原子性操作。  

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

r.set('name', 'alex')
r.set('role', 'sb')

pipe.execute()

  5、发布订阅

  

  发布者:服务器  

  订阅者:Dashboad和数据处理

  Demo如下:

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

import redis

class RedisHelper:

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

RedisHelper

  发布者:

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

from monitor.RedisHelper import RedisHelper

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

更多参见:https://github.com/andymccurdy/redis-py/

http://doc.redisfans.com/

python_redis之篇的更多相关文章

  1. TGL站长关于常见问题的回复

    问题地址: http://www.thegrouplet.com/thread-112923-1-1.html 问题: 网站配有太多的模板是否影响网站加载速度 月光答复: wp不需要删除其他的模板,不 ...

  2. 故障重现(内存篇2),JAVA内存不足导致频繁回收和swap引起的性能问题

    背景起因: 记起以前的另一次也是关于内存的调优分享下   有个系统平时运行非常稳定运行(没经历过大并发考验),然而在一次活动后,人数并发一上来后,系统开始卡. 我按经验开始调优,在每个关键步骤的加入如 ...

  3. 论:开发者信仰之“天下IT是一家“(Java .NET篇)

    比尔盖茨公认的IT界领军人物,打造了辉煌一时的PC时代. 2008年,史蒂夫鲍尔默接替了盖茨的工作,成为微软公司的总裁. 2013年他与微软做了最后的道别. 2013年以后,我才真正看到了微软的变化. ...

  4. [ 高并发]Java高并发编程系列第二篇--线程同步

    高并发,听起来高大上的一个词汇,在身处于互联网潮的社会大趋势下,高并发赋予了更多的传奇色彩.首先,我们可以看到很多招聘中,会提到有高并发项目者优先.高并发,意味着,你的前雇主,有很大的业务层面的需求, ...

  5. [高并发]Java高并发编程系列开山篇--线程实现

    Java是最早开始有并发的语言之一,再过去传统多任务的模式下,人们发现很难解决一些更为复杂的问题,这个时候我们就有了并发. 引用 多线程比多任务更加有挑战.多线程是在同一个程序内部并行执行,因此会对相 ...

  6. 操作系统篇-调用门与特权级(CPL、DPL和RPL)

    || 版权声明:本文为博主原创文章,未经博主允许不得转载. 一.前言 在前两篇文章(<操作系统篇-浅谈实模式与保护模式>和<操作系统篇-分段机制与GDT|LDT>)中,我们提到 ...

  7. 通过AngularJS实现前端与后台的数据对接(二)——服务(service,$http)篇

    什么是服务? 服务提供了一种能在应用的整个生命周期内保持数据的方法,它能够在控制器之间进行通信,并且能保证数据的一致性. 服务是一个单例对象,在每个应用中只会被实例化一次(被$injector实例化) ...

  8. javascript动画系列第三篇——碰撞检测

    前面的话 前面分别介绍了拖拽模拟和磁性吸附,当可视区域内存在多个可拖拽元素,就出现碰撞检测的问题,这也是javascript动画的一个经典问题.本篇将详细介绍碰撞检测 原理介绍 碰撞检测的方法有很多, ...

  9. 从0开始搭建SQL Server AlwaysOn 第一篇(配置域控)

    从0开始搭建SQL Server AlwaysOn 第一篇(配置域控) 第一篇http://www.cnblogs.com/lyhabc/p/4678330.html第二篇http://www.cnb ...

随机推荐

  1. C#移动跨平台开发(2)Xamarin移动跨平台解决方案是如何工作的?

    概述 上一篇 C#移动跨平台开发(1)环境准备发布之后不久,无独有偶,微软宣布了开放.NET框架源代码并且会为Windows.Mac和Linux开发一个核心运行时(Core CLR),这也是开源的!I ...

  2. ping 出现负值

    遇到一个问题,使用ping 命令的时候会出现负值.网上查询得知 AMD双核CPU,要打上CPU厂家提供的驱动补丁和微软的双核补.

  3. assign() 方法

    assign() 方法可加载一个新的文档. 语法 location.assign(URL) <html> <head> <script type="text/j ...

  4. Codeforces #369 div2 D.Directed Roads

    D. Directed Roads time limit per test2 seconds memory limit per test256 megabytes inputstandard inpu ...

  5. 为Asp.net MVC中的RenderSection设置默认内容

    1. RenderSection的简单介绍 Asp.net MVC中提供了RenderSection方法,这样就能够在Layout中定义一些区块,这些区块留给使用Layout的view来实现比如我们定 ...

  6. poj2194Stacking Cylinders

    链接 可以根据反余弦和反正切算出角a和b的值, 然后向量旋转就可以了,图中的状态旋转rotate((2,0),a+b)  反状态把角度反过来,点取(-2,0)即可. 不知道是不是理解错了,题意写着两圆 ...

  7. FSL安装

    本文介绍如何安装医学图像处理软件fsl. 安装环境:Win8和Ubuntu 14.04 LTS(双系统和虚拟机皆可) 1. 安装ubuntu 14.04 LTS 2. 打开终端,设置ip代理:expo ...

  8. 初学java之(盒子分布)

    import javax.swing.*; import java.awt.*; class WinGrid extends JFrame { Box basebox , boxv1,boxv2; p ...

  9. Flash与IE奇怪的关键字冲突

    我有一个小小的swf文件,用来播放声音,加入到HTML后,在Firefox/chrome下播放正常,唯独IE8提示 消息: 对象不支持此属性或方法 行: 48 字符: 3 代码: 0 URI: ... ...

  10. iOS反射机制

    iOS属性反射:说白了,就是将两个对象的所有属性,用动态的方式取出来,并根据属性名,自动绑值.(注意:对象的类,如果是派生类,就得靠其他方式来实现了,因为得到不该基类的属性.) 本人常用的反射方式,有 ...