官网命令（英文）列表：http://redis.io/commands 

Redis 教程：http://www.redis.net.cn/tutorial/3501.html

1、连接操作相关的命令quit：关闭连接（connection）auth：简单密码认证2、对value操作的命令exists(key)：  确认一个key是否存在del(key)：     删除一个keytype(key)：    返回值的类型keys(pattern)：返回满足给定pattern的所有keyrandomkey：    随机返回key空间的一个keyrename(oldname, newname)：将key由oldname重命名为newname，若newname存在则删除newname表示的keydbsize：  返回当前数据库中key的数目expire：  设定一个key的活动时间（s）ttl：     获得一个key的活动时间select(index)：     按索引查询move(key, dbindex)：将当前数据库中的key转移到有dbindex索引的数据库flushdb：           删除当前选择数据库中的所有keyflushall：          删除所有数据库中的所有key3、对String操作的命令set(key, value)：   给数据库中名称为key的string赋予值valueget(key)：          返回数据库中名称为key的string的valuegetset(key, value)：给名称为key的string赋予上一次的valuemget(key1, key2,…, key N)：   返回库中多个string（它们的名称为key1，key2…）的valuesetnx(key, value)：           如果不存在名称为key的string，则向库中添加string，名称为key，值为valuesetex(key, time, value)：     向库中添加string（名称为key，值为value）同时，设定过期时间timemset(key1, value1, key2, value2,…key N, value N)：  同时给多个string赋值，名称为key i的string赋值value imsetnx(key1, value1, key2, value2,…key N, value N)：如果所有名称为key i的string都不存在，则向库中添加string，名称key i赋值为value iincr(key)：名称为key的string增1操作incrby(key, integer)：名称为key的string增加integerdecr(key)：名称为key的string减1操作decrby(key, integer)：名称为key的string减少integerappend(key, value)：名称为key的string的值附加valuesubstr(key, start, end)：返回名称为key的string的value的子串4、对List操作的命令rpush(key, value)：在名称为key的list尾添加一个值为value的元素lpush(key, value)：在名称为key的list头添加一个值为value的 元素llen(key)：返回名称为key的list的长度lrange(key, start, end)：返回名称为key的list中start至end之间的元素（下标从0开始，下同）ltrim(key, start, end)：截取名称为key的list，保留start至end之间的元素lindex(key, index)：返回名称为key的list中index位置的元素lset(key, index, value)：给名称为key的list中index位置的元素赋值为valuelrem(key, count, value)：删除count个名称为key的list中值为value的元素。count为0，删除所有值为value的元素，count>0从头至尾删除count个值为value的元素，count<0从尾到头删除|count|个值为value的元素。 lpop(key)：返回并删除名称为key的list中的首元素 rpop(key)：返回并删除名称为key的list中的尾元素 blpop(key1, key2,… key N, timeout)：lpop命令的block版本。即当timeout为0时，若遇到名称为key i的list不存在或该list为空，则命令结束。如果timeout>0，则遇到上述情况时，等待timeout秒，如果问题没有解决，则对keyi+1开始的list执行pop操作。brpop(key1, key2,… key N, timeout)：rpop的block版本。参考上一命令。rpoplpush(srckey, dstkey)：返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部5、对Set操作的命令sadd(key, member)：向名称为key的set中添加元素membersrem(key, member) ：删除名称为key的set中的元素memberspop(key) ：随机返回并删除名称为key的set中一个元素smove(srckey, dstkey, member) ：将member元素从名称为srckey的集合移到名称为dstkey的集合scard(key) ：返回名称为key的set的基数sismember(key, member) ：测试member是否是名称为key的set的元素sinter(key1, key2,…key N) ：求交集sinterstore(dstkey, key1, key2,…key N) ：求交集并将交集保存到dstkey的集合sunion(key1, key2,…key N) ：求并集sunionstore(dstkey, key1, key2,…key N) ：求并集并将并集保存到dstkey的集合sdiff(key1, key2,…key N) ：求差集sdiffstore(dstkey, key1, key2,…key N) ：求差集并将差集保存到dstkey的集合smembers(key) ：返回名称为key的set的所有元素srandmember(key) ：随机返回名称为key的set的一个元素6、对zset（sorted set）操作的命令zadd(key, score, member)：向名称为key的zset中添加元素member，score用于排序。如该元素已存在，则根据score更新该元素的顺序。zrem(key, member) ：删除名称为key的zset中的元素memberzincrby(key, increment, member) ：如果在名称为key的zset中已经存在元素member，则该元素的score增加increment；否则向集合中添加该元素，其score的值为incrementzrank(key, member) ：返回名称为key的zset（元素已按score从小到大排序）中member元素的rank（即index，从0开始），若没有member元素，返回“nil”zrevrank(key, member) ：返回名称为key的zset（元素已按score从大到小排序）中member元素的rank（即index，从0开始），若没有member元素，返回“nil”zrange(key, start, end)：返回名称为key的zset（元素已按score从小到大排序）中的index从start到end的所有元素zrevrange(key, start, end)：返回名称为key的zset（元素已按score从大到小排序）中的index从start到end的所有元素zrangebyscore(key, min, max)：返回名称为key的zset中score >= min且score <= max的所有元素 zcard(key)：返回名称为key的zset的基数 zscore(key, element)：返回名称为key的zset中元素element的score zremrangebyrank(key, min, max)：删除名称为key的zset中rank >= min且rank <= max的所有元素 zremrangebyscore(key, min, max) ：删除名称为key的zset中score >= min且score <= max的所有元素zunionstore / zinterstore(dstkeyN, key1,…,keyN, WEIGHTS w1,…wN, AGGREGATE SUM|MIN|MAX)：对N个zset求并集和交集，并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score，在进行AGGREGATE运算前，都要乘以对于的WEIGHT参数。如果没有提供WEIGHT，默认为1。默认的AGGREGATE是SUM，即结果集合中元素的score是所有集合对应元素进行SUM运算的值，而MIN和MAX是指，结果集合中元素的score是所有集合对应元素中最小值和最大值。7、对Hash操作的命令hset(key, field, value)：向名称为key的hash中添加元素field<—>valuehget(key, field)：返回名称为key的hash中field对应的valuehmget(key, field1, …,field N)：返回名称为key的hash中field i对应的valuehmset(key, field1, value1,…,field N, value N)：向名称为key的hash中添加元素field i<—>value ihincrby(key, field, integer)：将名称为key的hash中field的value增加integerhexists(key, field)：名称为key的hash中是否存在键为field的域hdel(key, field)：删除名称为key的hash中键为field的域hlen(key)：返回名称为key的hash中元素个数hkeys(key)：返回名称为key的hash中所有键hvals(key)：返回名称为key的hash中所有键对应的valuehgetall(key)：返回名称为key的hash中所有的键（field）及其对应的value8、持久化save：将数据同步保存到磁盘bgsave：将数据异步保存到磁盘lastsave：返回上次成功将数据保存到磁盘的Unix时戳shundown：将数据同步保存到磁盘，然后关闭服务9、远程服务控制info：提供服务器的信息和统计monitor：实时转储收到的请求slaveof：改变复制策略设置config：在运行时配置Redis服务器

2、安装

sudo apt-get install redis-server
python 支持包： (其实就一个文件，搞过来就能用)
sudo apt-get install python-redis 

3、配置

配置一下吧,默认配置文件在： “/etc/redis/redis.conf”
绑定ip:
“bind 127.0.0.1″ -> “bind 10.0.1.7″将磁盘同步改为 不同步或每秒同步，一直同步的话太慢了:
“appendfsync always” -> “appendfsync no”检查一下后台执行是否打开:
“daemonize yes”或者其他你想设置的，例如:
连接超时时间 : “timeout 300″
运行级别: “loglevel notice” (个人认为默认的这个就挺好，非出现大异常，不用改为debug ) 

4、Python 操作 Redis 示例

redis-py 提供两个类 Redis 和 StrictRedis 用于实现 Redis 的命令。

• StrictRedis 用于实现大部分官方的命令，并使用官方的语法和命令（比如，SET命令对应与StrictRedis.set方法）。
      官方推荐使用 StrictRedis 方法。 
• Redis 是 StrictRedis 的子类，用于向后兼容旧版本的 redis-py。
  不推荐 Redis类，原因是它在 redis-cli 操作有些不一样，主要不一样是下面这三个方面。 
  • LREM：参数 ‘num’ 和 ‘value’ 的顺序交换了一下，cli 是 lrem queueName 0 ‘string’ 。  这里的0时所有的意思。 但是Redis这个类，把控制和string调换了。 
  • ZADD：实现时 score 和 value 的顺序不小心弄反了，后来有人用了，就这样了
  • SETEX：time 和 value 的顺序反了

#! /usr/bin/env python
#coding=utf-8
import redis
print redis.__file__r = redis.Redis(host='10.0.1.7', port=6379, db=1)      # 连接，可选不同数据库，这里选择 db=1# -----------------------------------------------------------------
info = r.info()                         # 看信息
for key in info:print "%s: %s" % (key, info[key])print '\ndbsize: %s' % r.dbsize()       # 查数据库大小
print "ping %s" % r.ping()              # 看连接
# r.select(2)                           # 选数据库
# r.move('a',2)                         # 移动数据去2数据库# 其他
# r.save('a')                # 存数据
# r.lastsave('a')            # 取最后一次save时间
# r.flush()                  # 刷新
# r.shutdown()               # 关闭所有客户端，停掉所有服务，退出服务器# -----------------------------------------------------------------
# 它有四种类型： string(key,value)、list(序列)、set(集合)、zset(有序集合,多了一个顺序属性)
# 不知道你用的哪种类型？
# print r.get_type('a') #可以告诉你
# -----------------------------------------------------------------# --------------------------- string操作 ---------------------------
print '-' * 20
r['c1'] = 'bar'        # 塞数据
# 或者
r.set('c2','bar')      # 塞数据print 'getset:', r.getset('c2','jj')    # 这里有个 getset属性，如果为True 可以在存新数据时将上次存储内容同时搞出来
print 'incr:', r.incr('a')               # 设置一个递增的整数 每执行一次它自加1：
print 'decr:', r.decr('a')               # 设置一个递减的整数print 'r['']:', r['c1']             # 取数据
# 或者
print 'get:', r.get('a')           # 取数据
# 或者 
print 'mget:', r.mget('c1','c2')    # 同时取一批
# 或者 
print 'keys:', r.keys('c*')         # 同时取一批 它们的名字(key)很像 而恰好你又不想输全部# 或者 
print 'randomkey:', r.randomkey()   # 随机取一个：print 'existes:', r.exists('a')     # 查看一个数据有没有 有是1， 没有是0
print 'delete:', r.delete('cc')     # 删数据 1是删除成功 0和None是没这个东西# ----------------------------批量操作----------------------------
print 'delete:', r.delete('c1','c2')# 其他
r.rename('a','c3')         # 改名
r.expire('c3',10)          # 让数据10秒后过期 说实话我不太明白么意思
r.ttl('c3')                # 看剩余过期时间 不存在返回-1# ---------------------------- 序列(list)操作：它是两头通的 ----------------------------
print '-'*20
r.push('b','gg')                # 塞入
r.push('b','hh')                # 塞入
r.push('b','ee',head=True)      # head 属性控制是不是从另一头塞
print 'list len:', r.llen('b')   # 看长度
print 'list lrange:', r.lrange('b',start=0,end=-1)   # 列出一批出来
print 'list index 0:', r.lindex('b',0)               # 取出一位# 修剪列表
# 若start 大于end, 则将这个list清空
print 'list ltrim :', r.ltrim('b',start=0,end=3) # 只留 从0到3四位# -------------------------------- 集合(set)操作 --------------------------------
r.sadd('s', 'a')       # 塞数据
r.scard('s')           # 判断一个set长度为多少, 即获取集合的成员数。不存在为0
r.sismember('s','a')   # 判断set中一个对象是否存在
r.sadd('s2','a')       
r.sinter('s1','s2')               # 求交集
r.sinterstore('s3','s1','s2')     # 求交集并将结果赋值
r.smembers('s3')                  # 看一个set对象
r.sunion('s1','s2')                   # 求并集
r.sunionstore('ss','s1','s2','s3')    # 求并集 并将结果返回
r.sdiff('s1','s2','s3')            # 在s1中有，但在s2和s3中都没有的数
r.sdiffstore('s4','s1','s2')       # 这个你懂的
r.srandmember('s1')              # 取个随机数# -------------------------------- 有序集合(zset)操作 --------------------------------
#'zadd', 'zcard', 'zincr', 'zrange', 'zrangebyscore', 'zrem', 'zscore'
# 分别对应：添加, 数量, 自加1, 取数据, 按照积分(范围)取数据, 删除, 取积分

5、使用 Python 操作 Redis

1. 安装 pyredis

首先安装pip

<SHELL># apt-get install python-pip
......
<SHELL># pip install --proxy=http://172.1.2.6:8080 redis
  Downloading redis-2.9.1.tar.gz (62kB): 62kB downloaded
  Running setup.py (path:/tmp/pip_build_root/redis/setup.py) egg_info for package redis
  ......
  Successfully installed redis
  Cleaning up...

也可以使用easy_install的方式来安装：easy_install redis

或者直接编译安装：

        wget https://pypi.python.org/packages/source/r/redis/redis-2.9.1.tar.gz
        tar xvzf redis-2.9.1.tar.gz
        cd redis-2.9.1
        python setup.py install

2 . 简单的 redis 操作

redis 连接实例是线程安全的，可以直接将 redis 连接实例设置为一个全局变量，直接使用。如果需要另一个Redis实例（or Redis数据库）时，就需要重新创建redis连接实例来获取一个新的连接。同理，python 的 redis 没有实现 select 命令。

>>> import redis
>>> r = redis.Redis(host='localhost',port=6379,db=0)
>>> r.set('guo','shuai')
True
>>> r.get('guo')
'shuai'
>>> r['guo']            
'shuai'
>>> r.keys()
['guo']
>>> r.dbsize()         #当前数据库包含多少条数据       
1L
>>> r.delete('guo')
1
>>> r.save()               #执行“检查点”操作，将数据写回磁盘。保存时阻塞
True
>>> r.get('guo');
>>> r.flushdb()        #清空r中的所有数据
True

3. pipeline 操作

管道（pipeline）是redis在提供单个请求中缓冲多条服务器命令的基类的子类。它通过减少服务器-客户端之间反复的TCP数据库包，从而大大提高了执行批量命令的功能。

>>> p = r.pipeline()        --创建一个管道
>>> p.set('hello','redis')
>>> p.sadd('faz','baz')
>>> p.incr('num')
>>> p.execute()
[True, 1, 1]
>>> r.get('hello')
'redis'

管道的命令可以写在一起，如：

>>> p.set('hello','redis').sadd('faz','baz').incr('num').execute()

默认的情况下，管道里执行的命令可以保证执行的原子性，执行pipe = r.pipeline(transaction=False)可以禁用这一特性。

Redis 连接池 

Redis 的连接池的方法：

pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
r = redis.Redis(connection_pool=pool)

 StrictRedis的连接池的实现方式:

pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.StrictRedis(connection_pool=pool)

看下官方的创建redis的时候，都可以添加什么参数。 

class redis.StrictRedis(host='localhost', port=6379, db=0, password=None, socket_timeout=None, connection_pool=None, charset='utf-8', errors='strict', decode_responses=False, unix_socket_path=None
)# Implementation of the Redis protocol.
# This abstract class provides a Python interface to all Redis commands and an implementation of the Redis protocol.
# Connection and Pipeline derive from this, implementing how the commands are sent and received to the Redis server

redis 的连接附加的参数里面，默认编码是utf-8

Python Redis pipeline操作：https://www.cnblogs.com/kangoroo/p/7647052.html

 Pipeline：“管道”，和很多设计模式中的“管道”具有同样的概念，pipleline的操作，将明确client与server端的交互，都是“单向的”：你可以将多个command，依次发给server，但在此期间，你将无法获得单个command的响应数据，此后你可以关闭“请求”，然后依次获取每个command的响应结果。
 

    从简单来说，在IO操作层面，对于client而言，就是一次批量的连续的“write”请求，然后是批量的连续的“read”操作。其实对于底层Socket-IO而言，对于client而言，只不过是多次write，然后一次read的操作；对于server端，input通道上read到数据之后，就会立即被实施，也会和非pipeline一样在output通道上输出执行的结果，只不过此时数据会被阻塞在网络缓冲区上，直到client端开始read或者关闭链接。神秘的面纱已被解开，或许你也能创造一个pipeline的实现。

redis通过pipeline提升吞吐量：https://www.cnblogs.com/littleatp/p/8419796.html

非pipleline模式：
    client                    server
    Request    ---->    执行
                     <----    Response
    Request    ---->    执行
                     <----    Response

Pipeline模式下：
    client                    server
    Request    ---->    执行。Server将响应结果队列化
    Request    ---->    执行。Server将响应结果队列化
                     <----    Response
                     <----    Response

    Client端根据Redis的数据协议，将响应结果进行解析，并将结果做类似于“队列化”的操作。

从两个图的对比中可看出，普通的请求模型是同步的，每次请求对应一次IO操作等待；

而Pipeline 化之后所有的请求合并为一次IO，除了时延可以降低之外，还能大幅度提升系统吞吐量。

• pipeline机制可以优化吞吐量，但无法提供原子性/事务保障，而这个可以通过Redis-Multi等命令实现。
  参考这里：https://redis.io/topics/transactions
• 部分读写操作存在相关依赖，无法使用pipeline实现，可利用Script机制，但需要在可维护性方面做好取舍。

官方文档-Redis-Pipelining
官方文档-Redis-Transaction

pipeline 和“事务”是两个完全不同的概念。pipeline只是表达“交互”中操作的传递的方向性，pipeline也可以在事务中运行，也可以不在。无论如何，pipeline中发送的每个command都会被server立即执行，如果执行失败，将会在此后的相应中得到信息；也就是pipeline并不是表达“所有command都一起成功”的语义；但是如果pipeline的操作被封装在事务中，那么将有事务来确保操作的成功与失败（事实上，Redis的事务，仍然不像严格意义上的事务

pipeline 只是把多个redis指令一起发出去，redis并没有保证这些指定的执行是原子的。
multi 相当于一个 redis 的 transaction 的，保证整个操作的原子性，避免由于中途出错而导致最后产生的数据不一致。
pipeline 方式执行效率要比其他方式高。启用 multi 写入要比没有开启 multi 慢一点。

 Pipeline在某些场景下非常有用，比如有多个command需要被“及时的”提交，而且他们对相应结果没有互相依赖，而且对结果响应也无需立即获得，那么pipeline就可以充当这种“批处理”的工具；而且在一定程度上，可以较大的提升性能,性能提升的原因主要是TCP链接中较少了“交互往返”的时间。

pipeline 期间将“独占”链接，此期间将不能进行非“管道”类型的其他操作，直到pipeline关闭；
如果你的pipeline的指令集很庞大，为了不干扰链接中的其他操作，你可以为pipeline操作新建Client链接，让pipeline和其他正常操作分离在2个client中。不过pipeline事实上所能容忍的操作个数，和socket-output缓冲区大小/返回结果的数据尺寸都有很大的关系；同时也意味着每个redis-server同时所能支撑的pipeline链接的个数，也是有限的，这将受限于server的物理内存或网络接口的缓冲能力。

Transaction(事务)：
 

Redis 事务 以及 Python 操作示例 ：http://www.cnblogs.com/kangoroo/p/7535405.html

    Redis提供了简单的“事务”能力,MULTI,EXEC,DISCARD,WATCH/UNWATCH指令用来操作事务。

    只有把 watch命令结合起来用，方可显现出其具有事务的功能

1.     MUTIL：开启事务，此后所有的操作将会添加到当前链接的事务“操作队列”中。
2.     EXEC：提交事务
3.     DISCARD：取消事务，记住，此指令不是严格意义上的“事务回滚”，只是表达了“事务操作被取消”的语义，将会导致事务的操作队列中的操作不会被执行，且事务关闭。
4.     WATCH/UNWATCH：“观察”，这个操作也可以说是Redis的特殊功能，但是也可说是Redis不能提供“绝对意义上”的事务能力而增加的一个“补充特性”（比如事务隔离，多事务中操作冲突解决等）；在事务开启前，可以对某个KEY注册“WATCH”，如果在事务提交后，将会首先检测“WATCH”列表中的KEY集合是否被其他客户端修改，如果任意一个KEY 被修改，都将会导致事务直接被“DISCARD”；即使事务中没有操作某个WATCH KEY，如果此KEY被外部修改，仍然会导致事务取消。事务执行成功或者被DISCARD，都将会导致WATCH KEY被“UNWATCH”，因此事务之后，你需要重新WATCH。WATCH需要在事务开启之前执行。

WATCH所注册的KEY，事实上无论是被其他Client修改还是当前Client修改，如果不重新WATCH，都将无法在事务中正确执行。WATCH指令本身就是为事务而生，你或许不会在其他场景下使用WATCH

Redis中，如果一个事务被提交，那么事务中的所有操作将会被顺序执行，且在事务执行期间，其他client的操作将会被阻塞；Redis采取了这种简单而“粗鲁”的方式来确保事务的执行更加的快速和更少的外部干扰因素。

EXEC指令将会触发事务中所有的操作被写入AOF文件（如果开启了AOF），然后开始在内存中实施这些数据变更操作；Redis将会尽力确保事务中所有的操作都能够执行，如果redis环境故障，有可能导致事务未能成功执行，那么需要在redis重启后增加额外的校验工作。

   如果在EXEC指令被提交之前，Redis-server即检测到提交的某个指令存在语法错误，那么此事务将会被提前标记为DISCARD，此后事务提交也将直接被驳回；但是如果在EXEC提交后，在实施数据变更时（Redis将不会预检测数据类型，比如你对一个“非数字”类型的key执行INCR操作），某个操作导致了ERROR，那么redis仍然不会回滚此前已经执行成功的操作，而且也不会中断ERROR之后的其他操作继续执行。对于开发者而言，你务必关注事务执行后返回的结果（结果将是一个集合，按照操作提交的顺序排列，对于执行失败的操作，结果将是一个ERROR）。

    Redis的事务之所以如此设计，它为了确保本身的性能，同时不引入“关系型数据库”的设计复杂度

总结：

1. Multi :
　　1.1. 每发送一条指令，都需要单独发给服务器，服务器再单独返回“该条指令已加入队列”这个消息。这是比Pipeline慢的原因之一。
　　1.2. Multi执行的时候会先暂停其他命令的执行，类似于加了个锁，直到整个Multi结束完成再继续其他客户端的请求。这是Multi能保证一致性的原因，也是比Pipeline慢的原因之二。（需要读Redis Server的代码，从TCPDump上看不出）

2. Pipeline :
　　2.1. 将所有命令打包一次性发送。发送成功后，服务端不用返回类似“命令已收到”这样的消息，而是一次性批量执行所有命令，成功后再一次性返回所有处理结果。
　　2.2. 服务端处理命令的时候，不需要加锁，而是与其他客户端的命令混合在一起处理，所以无法保证一致性。

适用场景 ：
1. 如果要顺序执行一组命令（既网上所谓的“Redis事务”），Multi很合适。
2. 如果要往Redis里批量插入Log, 或者使用Redis List做为队列并插入很多消息的话，Pipleline是挺合适的。 

示例代码：

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author      : 
# @File        : test.py
# @Software    : PyCharm
# @description : Redis 事务 和 锁机制 import redis
import time
from redis import WatchError
import multiprocessingREDIS_HOST = '127.0.0.1'
REDIS_PORT = 6379
r_pool = redis.ConnectionPool(host=REDIS_HOST, port=REDIS_PORT)
r = redis.StrictRedis(connection_pool=r_pool)def add_data():for v in range(100):r.zadd('set', v, v)def run(name):loop = Truewith r.pipeline() as pipe:while loop:try:pipe.zrevrange('set', -9999999999, 9999999999, withscores=True)[0]row_value_score = pipe.execute()[0][0]  # <class 'tuple'>: (b'99', 99.0)value = row_value_score[0]pipe.watch('set')pipe.multi()results = pipe.zrem('set', value.decode('utf-8')).execute()pipe.unwatch()  # 没有发生异常时，删除锁if results[0]:# 删除成功，继续删除 下一条数据print('{0} {1}'.format(name, results), end='')print(' value: {0}, score: {1}'.format(row_value_score[0], row_value_score[1]))else:# 删除失败(说明数据已经被别的进程删除)。继续删除下一条数据print('{0} 删除失败，读取数据 '.format(name), end='')print('{0} {1}'.format(name, results), end='')print(' value: {0}, score: {1}'.format(row_value_score[0], row_value_score[1]))except WatchError as watch_error:pipe.unwatch()print(watch_error, '{0} 释放锁，继续下次循环'.format(name))except IndexError as index_error:loop = False# print(index_error)except BaseException as e:print(e)# print('hello', name)time.sleep(0.2)if __name__ == '__main__':add_data()process_nums = []for i in range(100):  # 起 100 个进程p = multiprocessing.Process(target=run, args=('process_%s' % i,))process_nums.append(p)p.start()for i in range(len(process_nums)):process_nums[i].join()pass

可以把 代码中 time.sleep(0.2) 的代码注释掉看下效果（下面是有睡眠时间的运行结果）：

process_1 [1] value: b'99', score: 99.0
process_2 [1] value: b'98', score: 98.0
process_0 [1] value: b'97', score: 97.0
process_3 [1] value: b'96', score: 96.0
process_4 [1] value: b'95', score: 95.0
process_1 [1] value: b'94', score: 94.0
process_2 [1] value: b'93', score: 93.0
process_0 [1] value: b'92', score: 92.0
process_3 [1] value: b'91', score: 91.0
process_5 [1] value: b'90', score: 90.0
process_4 [1] value: b'89', score: 89.0
process_1 [1] value: b'88', score: 88.0
process_7 [1] value: b'87', score: 87.0
process_2 [1] value: b'86', score: 86.0
process_9 [1] value: b'85', score: 85.0
process_0 [1] value: b'84', score: 84.0
process_6 删除失败，读取数据 process_6 [0] value: b'84', score: 84.0
process_3 [1] value: b'83', score: 83.0
process_5 [1] value: b'82', score: 82.0
process_4 [1] value: b'81', score: 81.0
process_8 [1] value: b'80', score: 80.0
process_1 [1] value: b'79', score: 79.0
process_7 [1] value: b'78', score: 78.0
process_2 [1] value: b'77', score: 77.0
Watched variable changed. process_9 释放锁，继续下次循环
Watched variable changed. process_6 释放锁，继续下次循环
Watched variable changed. process_0 释放锁，继续下次循环
Watched variable changed. process_3 释放锁，继续下次循环
Watched variable changed. process_5 释放锁，继续下次循环
process_4 删除失败，读取数据 process_4 [0] value: b'77', score: 77.0
process_8 [1] value: b'76', score: 76.0
process_10 [1] value: b'75', score: 75.0
Watched variable changed. process_11 释放锁，继续下次循环
process_1 [1] value: b'74', score: 74.0
process_7 [1] value: b'73', score: 73.0
process_13 [1] value: b'72', score: 72.0
process_6 [1] value: b'71', score: 71.0
Watched variable changed. process_9 释放锁，继续下次循环
Watched variable changed. process_0 释放锁，继续下次循环
process_2 删除失败，读取数据 process_2 [0] value: b'71', score: 71.0
process_5 [1] value: b'70', score: 70.0
process_3 删除失败，读取数据 process_3 [0] value: b'70', score: 70.0
process_4 删除失败，读取数据 process_4 [0] value: b'70', score: 70.0
process_8 删除失败，读取数据 process_8 [0] value: b'70', score: 70.0
process_11 [1] value: b'69', score: 69.0
process_10 删除失败，读取数据 process_10 [0] value: b'69', score: 69.0
process_1 [1] value: b'68', score: 68.0
process_7 [1] value: b'67', score: 67.0
process_12 [1] value: b'66', score: 66.0
process_15 [1] value: b'65', score: 65.0
process_13 [1] value: b'64', score: 64.0
process_6 [1] value: b'63', score: 63.0
process_9 [1] value: b'62', score: 62.0
process_0 删除失败，读取数据 process_0 [0] value: b'62', score: 62.0
process_2 删除失败，读取数据 process_2 [0] value: b'62', score: 62.0
process_5 删除失败，读取数据 process_5 [0] value: b'62', score: 62.0
process_8 删除失败，读取数据 process_8 [0] value: b'62', score: 62.0
process_4 [1] value: b'61', score: 61.0
Watched variable changed. process_3 释放锁，继续下次循环
process_11 [1] value: b'60', score: 60.0
process_10 [1] value: b'59', score: 59.0
process_1 [1] value: b'58', score: 58.0
process_7 [1] value: b'57', score: 57.0
process_12 [1] value: b'56', score: 56.0
process_14 [1] value: b'55', score: 55.0
process_16 删除失败，读取数据 process_16 [0] value: b'55', score: 55.0
process_15 [1] value: b'54', score: 54.0
process_13 [1] value: b'53', score: 53.0
process_6 [1] value: b'52', score: 52.0
process_9 [1] value: b'51', score: 51.0
process_8 [1] value: b'50', score: 50.0
Watched variable changed. process_3 释放锁，继续下次循环
process_5 删除失败，读取数据 process_5 [0] value: b'50', score: 50.0
Watched variable changed. process_4 释放锁，继续下次循环
process_2 删除失败，读取数据 process_2 [0] value: b'50', score: 50.0
process_0 删除失败，读取数据 process_0 [0] value: b'50', score: 50.0
process_11 [1] value: b'49', score: 49.0
process_10 [1] value: b'48', score: 48.0
process_1 [1] value: b'47', score: 47.0
process_7 [1] value: b'46', score: 46.0
process_12 [1] value: b'45', score: 45.0
process_14 [1] value: b'44', score: 44.0
Watched variable changed. process_16 释放锁，继续下次循环
process_15 [1] value: b'43', score: 43.0
process_22 [1] value: b'42', score: 42.0
process_13 [1] value: b'41', score: 41.0
process_6 [1] value: b'40', score: 40.0
process_9 [1] value: b'39', score: 39.0
process_0 删除失败，读取数据 process_0 [0] value: b'39', score: 39.0
process_2 删除失败，读取数据 process_2 [0] value: b'39', score: 39.0
process_4 [1] value: b'38', score: 38.0
Watched variable changed. process_5 释放锁，继续下次循环
process_3 删除失败，读取数据 process_3 [0] value: b'38', score: 38.0
process_8 删除失败，读取数据 process_8 [0] value: b'38', score: 38.0
process_17 [1] value: b'37', score: 37.0
process_21 [1] value: b'36', score: 36.0
process_11 [1] value: b'35', score: 35.0
Watched variable changed. process_10 释放锁，继续下次循环
process_1 [1] value: b'34', score: 34.0
process_7 [1] value: b'33', score: 33.0
process_12 [1] value: b'32', score: 32.0
process_14 [1] value: b'31', score: 31.0
process_16 删除失败，读取数据 process_16 [0] value: b'31', score: 31.0
process_19 [1] value: b'30', score: 30.0
process_15 [1] value: b'29', score: 29.0
process_20 [1] value: b'28', score: 28.0
process_18 [1] value: b'27', score: 27.0
process_22 [1] value: b'26', score: 26.0
process_13 [1] value: b'25', score: 25.0
process_6 [1] value: b'24', score: 24.0
process_9 [1] value: b'23', score: 23.0
process_0 删除失败，读取数据 process_0 [0] value: b'23', score: 23.0
process_2 [1] value: b'22', score: 22.0
process_4 删除失败，读取数据 process_4 [0] value: b'22', score: 22.0
process_3 [1] value: b'21', score: 21.0
Watched variable changed. process_5 释放锁，继续下次循环
process_8 [1] value: b'20', score: 20.0
process_21 [1] value: b'19', score: 19.0
process_10 [1] value: b'18', score: 18.0
Watched variable changed. process_11 释放锁，继续下次循环
process_1 [1] value: b'17', score: 17.0
process_7 [1] value: b'16', score: 16.0
process_12 [1] value: b'15', score: 15.0
process_16 [1] value: b'13', score: 13.0
process_14 删除失败，读取数据 process_14 [0] value: b'13', score: 13.0
process_17 [1] value: b'14', score: 14.0
process_19 [1] value: b'12', score: 12.0
process_15 [1] value: b'11', score: 11.0
process_23 [1] value: b'10', score: 10.0
process_20 [1] value: b'9', score: 9.0
process_18 [1] value: b'8', score: 8.0
process_22 [1] value: b'7', score: 7.0
process_13 [1] value: b'6', score: 6.0
process_6 [1] value: b'5', score: 5.0
process_9 [1] value: b'4', score: 4.0
process_0 [1] value: b'3', score: 3.0
process_2 [1] value: b'2', score: 2.0
process_5 [1] value: b'1', score: 1.0
process_3 [1] value: b'0', score: 0.0Process finished with exit code 0

4. 应用场景 – 页面点击数

《Redis Cookbook》对这个经典场景进行详细描述。假定我们对一系列页面需要记录点击次数。例如论坛的每个帖子都要记录点击次数，而点击次数比回帖的次数的多得多。如果使用关系数据库来存储点击，可能存在大量的行级锁争用。所以，点击数的增加使用redis的INCR命令最好不过了。
当redis服务器启动时，可以从关系数据库读入点击数的初始值（1237这个页面被访问了34634次）

>>> r.set("visit:1237:totals",34634)
True

每当有一个页面点击，则使用INCR增加点击数即可。

>>> r.incr("visit:1237:totals")
34635
>>> r.incr("visit:1237:totals")
34636

页面载入的时候则可直接获取这个值

>>> r.get ("visit:1237:totals")
'34636'

5. 使用hash类型保存多样化对象

当有大量类型文档的对象，文档的内容都不一样时，（即“表”没有固定的列），可以使用hash来表达。

>>> r.hset('users:jdoe',  'name', "John Doe")
1L
>>> r.hset('users:jdoe', 'email', 'John@test.com')
1L
>>> r.hset('users:jdoe',  'phone', '1555313940')
1L
>>> r.hincrby('users:jdoe', 'visits', 1)
1L
>>> r.hgetall('users:jdoe')
{'phone': '1555313940', 'name': 'John Doe', 'visits': '1', 'email': 'John@test.com'}
>>> r.hkeys('users:jdoe')
['name', 'email', 'phone', 'visits']

6. 应用场景 – 社交圈子数据

在社交网站中，每一个圈子(circle)都有自己的用户群。通过圈子可以找到有共同特征（比如某一体育活动、游戏、电影等爱好者）的人。当一个用户加入一个或几个圈子后，系统可以向这个用户推荐圈子中的人。
我们定义这样两个圈子,并加入一些圈子成员。

>>> r.sadd('circle:game:lol','user:debugo')
1
>>> r.sadd('circle:game:lol','user:leo')
1
>>> r.sadd('circle:game:lol','user:Guo')
1
>>> r.sadd('circle:soccer:InterMilan','user:Guo')
1
>>> r.sadd('circle:soccer:InterMilan','user:Levis')
1
>>> r.sadd('circle:soccer:InterMilan','user:leo')
1

#获得某一圈子的成员

>>> r.smembers('circle:game:lol')
set(['user:Guo', 'user:debugo', 'user:leo'])
redis> smembers circle:jdoe:family    

可以使用集合运算来得到几个圈子的共同成员：

>>> r.sinter('circle:game:lol', 'circle:soccer:InterMilan')
set(['user:Guo', 'user:leo'])
>>> r.sunion('circle:game:lol', 'circle:soccer:InterMilan')
set(['user:Levis', 'user:Guo', 'user:debugo', 'user:leo'])

7. 应用场景 – 实时用户统计

Counting Online Users with Redis介绍了这个方法。当我们需要在页面上显示当前的在线用户时，就可以使用Redis来完成了。首先获得当前时间（以Unix timestamps方式）除以60，可以基于这个值创建一个key。然后添加用户到这个集合中。当超过你设定的最大的超时时间，则将这个集合设为过期；而当需要查询当前在线用户的时候，则将最后N分钟的集合交集在一起即可。由于redis连接对象是线程安全的，所以可以直接使用一个全局变量来表示。

import time
import redis
from datetime import datetime
ONLINE_LAST_MINUTES = 5
r = redis.Redis()def mark_online(user_id):         #将一个用户标记为onlinenow = int(time.time())        #当前的UNIX时间戳expires = now + (app.config['ONLINE_LAST_MINUTES'] * 60) + 10    #过期的UNIX时间戳all_users_key = 'online-users/%d' % (now // 60)        #集合名，包含分钟信息user_key = 'user-activity/%s' % user_id                p = r.pipeline()p.sadd(all_users_key, user_id)                         #将用户id插入到包含分钟信息的集合中p.set(user_key, now)                                   #记录用户的标记时间p.expireat(all_users_key, expires)                     #设定集合的过期时间为UNIX的时间戳p.expireat(user_key, expires)p.execute()def get_user_last_activity(user_id):        #获得用户的最后活跃时间last_active = r.get('user-activity/%s' % user_id)  #如果获取不到，则返回Noneif last_active is None:return Nonereturn datetime.utcfromtimestamp(int(last_active))def get_online_users():                     #获得当前online用户的列表current = int(time.time()) // 60        minutes = xrange(app.config['ONLINE_LAST_MINUTES'])return r.sunion(['online-users/%d' % (current - x)        #取ONLINE_LAST_MINUTES分钟对应集合的交集for x in minutes])

redis基本命令和基本用法详解

1、redis连接

redis-py 提供两个类 Redis 和 StrictRedis 用于实现 Redis 的命令，StrictRedis 用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。import redis 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库r = redis.Redis(host='192.168.19.130', port=6379) host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379r.set('foo', 'Bar') key是"foo" value是"bar" 将键值对存入redis缓存print r.get('foo') Bar 取出键foo对应的值

2、连接池

redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池import redis 通过python操作redis缓存pool = redis.ConnectionPool(host='192.168.19.130', port=6379)   # host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379
r = redis.Redis(connection_pool=pool)
r.set('foo', 'Bar')                                             # key是"foo" value是"bar" 将键值对存入redis缓存
print r.get('foo')                                              # Bar 取出键foo对应的值

3、redis基本命令_string

set(name, value, ex=None, px=None, nx=False, xx=False)在Redis中设置值，默认，不存在则创建，存在则修改
参数：
ex，过期时间（秒）
px，过期时间（毫秒）
nx，如果设置为True，则只有name不存在时，当前set操作才执行
xx，如果设置为True，则只有name存在时，当前set操作才执行import redis 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库pool = redis.ConnectionPool(host='192.168.19.130', port=6379)host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379r = redis.Redis(connection_pool=pool) 创建实例1 ex，过期时间（秒） 这里过期时间是3秒，3秒后p，键foo的值就变成None
r.set('foo', 'Bar',ex=3) key是"foo" value是"bar" 将键值对存入redis缓存
print r.get('foo') Bar 取出键foo对应的值2 px，过期时间（豪秒） 这里过期时间是3豪秒，3毫秒后，键foo的值就变成None
r.set('foo', 'Bar',px=3) key是"foo" value是"bar" 将键值对存入redis缓存
print r.get('foo') Bar 取出键foo对应的值3 nx，如果设置为True，则只有name不存在时，当前set操作才执行 （新建）
print(r.set('foo', 'Bar',nx=True)) None--已经存在
如果键foo已经存在，那么输出是True；如果键foo不存在，输出是None4 xx，如果设置为True，则只有name存在时，当前set操作才执行 （修改）
print(r.set('foo1', 'Bar',xx=True)) True--已经存在
如果键foo已经存在，那么输出是None；如果键foo不存在，输出是True5 setnx(name, value)
设置值，只有name不存在时，执行设置操作（添加）
print(r.setnx("foo2","bar")) False--已经存在的话，无法执行6 setex(name, value, time)
设置值
参数：
time，过期时间（数字秒 或 timedelta对象）
r.setex("foo","bar",5)
print r.get('foo') 5秒后，取值就从bar变成None7 psetex(name, time_ms, value)
设置值
参数：
time_ms，过期时间（数字毫秒 或 timedelta对象）
r.psetex("foo",5000,"bar")
print r.get('foo') 5000毫秒后，取值就从bar变成None8 mset(*args, **kwargs)
批量设置值
如：
mset(k1='v1', k2='v2')
或
mget({'k1': 'v1', 'k2': 'v2'})
r.mset(k1="v1",k2="v2") 这里k1 和k2 不能带引号 一次设置对个键值对
print r.mget("k1","k2") ['v1', 'v2'] 一次取出多个键对应的值
print r.mget("k1") ['v1']9 mget(keys, *args)
批量获取
如：
mget('ylr', 'wupeiqi')
或
r.mget(['ylr', 'wupeiqi'])
print r.mget("foo","foo1","foo2","k1","k2") [None, 'Bar', 'bar', 'v1', 'v2']
将目前redis缓存中的键对应的值批量取出来10 getset(name, value)
设置新值并获取原来的值
print(r.getset("foo1","bar_NEW")) Bar
设置的新值是"bar_NEW" 设置前的值是Bar11 getrange(key, start, end)
获取子序列（根据字节获取，非字符）
参数：
name，Redis 的 name
start，起始位置（字节）
end，结束位置（字节）
如： "武沛齐" ，0-3表示 "武"
r.set("foo1","武沛齐") 汉字
print(r.getrange("foo1",0,2)) 取索引号是0-2 前3位的字节 武 切片操作 （一个汉字3个字节 1个字母一个字节 每个字节8bit）
print(r.getrange("foo1",0,-1)) 取所有的字节 武沛齐 切片操作r.set("foo1","bar_new") 字母
print(r.getrange("foo1",0,2)) 取索引号是0-2 前3位的字节 bar 切片操作 （一个汉字3个字节 1个字母一个字节 每个字节8bit）
print(r.getrange("foo1",0,-1)) 取所有的字节 bar_new 切片操作12 setrange(name, offset, value)
修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
参数：
offset，字符串的索引，字节（一个汉字三个字节）
value，要设置的值
r.setrange("foo1",1,"aaa")
print(r.get("foo1")) baaanew 原始值是bar_new 从索引号是1开始替换成aaa 变成 baaanew
bar_new13 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
-------------------------- ----------------------------- -----------------------------
陈思维13 应用场景 ：统计uv
注：如果在Redis中有一个对应： n1 = "foo"，
那么字符串foo的二进制表示为：01100110 01101111 01101111
所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
那么最终二进制则变成 01100111 01101111 01101111，即："goo"
r.set("foo","foo1") foo1的二进制表示为：01100110 01101111 01101111 00110001
这里f对应的ascii值是102 折算二进制是 01100110 （64+32+4+2）
这里o对应的ascii值是111 折算二进制是 01101111 （64+32+8+4+2+1）
这里数字1对应的ascii值是49 折算二进制是 00110001 （32+16+1）
r.setbit("foo",7,1) 将第7位设置为1，
print(r.get("foo")) goo1
那么最终二进制则变成 01100111 01101111 01101111 00000001
print(ord("f")) 102 将字符f的ascii对应的值打印出来
print(ord("o")) 111 将字符o的ascii对应的值打印出来
print(chr(103)) g 将ascii数字103对应的字符打印出来
print(ord("1")) 49 将数字1的ascii对应的值打印出来扩展，转换二进制表示：
source = "陈思维"
source = "foo1"
for i in source:
num = ord(i)
print(num) 打印每个字母字符或者汉字字符对应的ascii码值 f-102-0b100111-01100111
print(bin(num)) 打印每个10进制ascii码值转换成二进制的值 0b1100110（0b表示二进制）
print bin(num).replace('b','') 将二进制0b1100110替换成01100110特别的，如果source是汉字 "陈思维"怎么办？
答：对于utf-8，每一个汉字占 3 个字节，那么 "陈思维" 则有 9个字节
对于汉字，for循环时候会按照 字节 迭代，那么在迭代时，将每一个字节转换 十进制数，然后再将十进制数转换成二进制
11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 1001000014 getbit(name, offset)
获取name对应的值的二进制表示中的某位的值 （0或1）
print(r.getbit("foo1",0)) 0 foo1对应的二进制 4个字节 32位 第0位是0还是115 bitcount(key, start=None, end=None)
获取name对应的值的二进制表示中 1 的个数
参数：
key，Redis的name
start 字节起始位置
end，字节结束位置
print(r.get("foo")) goo1 01100111
print(r.bitcount("foo",0,1)) 11 表示前2个字节中，1出现的个数16 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 对应的值中
r.set("foo","1") 0110001
r.set("foo1","2") 0110010
print(r.mget("foo","foo1")) ['goo1', 'baaanew']
print(r.bitop("AND","new","foo","foo1")) "new" 0 0110000
print(r.mget("foo","foo1","new"))source = "12"
for i in source:
num = ord(i)
print(num) 打印每个字母字符或者汉字字符对应的ascii码值 f-102-0b100111-01100111
print(bin(num)) 打印每个10进制ascii码值转换成二进制的值 0b1100110（0b表示二进制）
print bin(num).replace('b','') 将二进制0b1100110替换成0110011017 strlen(name)
返回name对应值的字节长度（一个汉字3个字节）
print(r.strlen("foo")) 4 'goo1'的长度是418 incr(self, name, amount=1)
自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
参数：
name,Redis的name
amount,自增数（必须是整数）
注：同incrby
r.set("foo",123)
print r.mget("foo","foo1","foo2","k1","k2") ['123', '2', 'bar', 'v1', 'v2']
r.incr("foo",amount=1)
print r.mget("foo","foo1","foo2","k1","k2") ['124', '2', 'bar', 'v1', 'v2']19 incrbyfloat(self, name, amount=1.0)
自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
参数：
name,Redis的name
amount,自增数（浮点型）
r.set("foo1","123.0")
print r.mget("foo","foo1","foo2","k1","k2") ['124', '123.0', 'bar', 'v1', 'v2']
r.incrbyfloat("foo1",amount=2.0)
r.incrbyfloat("foo3",amount=3.0)
print r.mget("foo","foo1","foo2","foo3","k1","k2") ['124', '125', 'bar', '-3', 'v1', 'v2']20 decr(self, name, amount=1)
自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
参数：
name,Redis的name
amount,自减数（整数)
r.decr("foo4",amount=3) 递减3
r.decr("foo1",amount=1) 递减1
print r.mget("foo","foo1","foo2","foo3","foo4","k1","k2")
['goo1', '121', 'bar', '15', '-18', 'v1', 'v2']21 append(key, value)
在redis name对应的值后面追加内容
参数：
key, redis的name
value, 要追加的字符串
r.append("foo","abc") 在foo对应的值goo1后面追加字符串abc
print r.mget("foo","foo1","foo2","foo3","foo4","k1","k2")
['goo1abc', '121', 'bar', '15', '-18', 'v1', 'v2']

4 redis基本命令_hash

import redis 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库pool = redis.ConnectionPool(host='192.168.19.130', port=6379)host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379r = redis.Redis(connection_pool=pool) 创建实例1 单个增加--修改(单个取出)--没有就新增，有的话就修改
hset(name, key, value)
name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
参数：
name，redis的name
key，name对应的hash中的key
value，name对应的hash中的value
注：
hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
r.hset("foo_hash1","k1","v1")
print(r.mget("foo","foo1","foo2","foo3","foo4","k1","k2"))
['goo1abcabc', '121', 'bar', '15', '-18', 'v1', 'v2'] 取字符串
print(r.hget("foo_hash1","k1")) v1 单个取hash的key
print(r.hmget("foo_hash1","k1")) ['v1'] 批量取hash的keyr.hsetnx("foo_hash1","k2","v2") 只能新建
print(r.hget("foo_hash1","k2")) v2
print(r.hmget("foo_hash1","k2")) ['v2']2 批量增加（取出）
hmset(name, mapping)
在name对应的hash中批量设置键值对
参数：
name，redis的name
mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
如：
r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
r.hmset("foo_hash2",{"k2":"v2","k3":"v3"})
print(r.hget("foo_hash2","k2")) v2
单个取出"foo_hash2"的key-k2对应的value
print(r.hmget("foo_hash2","k2","k3")) ['v2', 'v3']
批量取出"foo_hash2"的key-k2 k3对应的value --方式1
print(r.hmget("foo_hash2",["k2","k3"])) ['v2', 'v3']
批量取出"foo_hash2"的key-k2 k3对应的value --方式2hget(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.hmget('xx', ['k1', 'k2'])
或
print r.hmget('xx', 'k1', 'k2')3 取出所有的键值对
hgetall(name)
获取name对应hash的所有键值
print(r.hgetall("foo_hash1"))
{'k2': 'v2', 'k1': 'v1'}4 得到所有键值对的格式 hash长度
hlen(name)
获取name对应的hash中键值对的个数
print(r.hlen("foo_hash1")) 25 得到所有的keys（类似字典的取所有keys）
hkeys(name)
获取name对应的hash中所有的key的值
print(r.hkeys("foo_hash1")) ['k1', 'k2'] 取出所有的keys6 得到所有的value（类似字典的取所有value）
hvals(name)
获取name对应的hash中所有的value的值
print(r.hvals("foo_hash1")) ['v1', 'v2'] 取出所有的values7 判断成员是否存在（类似字典的in）
hexists(name, key)
检查name对应的hash是否存在当前传入的key
print(r.hexists("foo_hash1","k3")) False 不存在
print(r.hexists("foo_hash1","k1")) True 存在8 删除键值对
hdel(name,*keys)
将name对应的hash中指定key的键值对删除
print(r.hgetall("foo_hash1")) {'k2': 'v2', 'k1': 'v1'}
r.hset("foo_hash1","k2","v3") 修改已有的key k2
r.hset("foo_hash1","k1","v1") 新增键值对 k1
r.hdel("foo_hash1","k1") 删除一个键值对
print(r.hgetall("foo_hash1")) {'k2': 'v3'}9 自增自减整数(将key对应的value--整数 自增1或者2，或者别的整数 负数就是自减)
hincrby(name, key, amount=1)
自增name对应的hash中的指定key的值，不存在则创建key=amount
参数：
name，redis中的name
key， hash对应的key
amount，自增数（整数）
r.hset("foo_hash1","k3",123)
r.hincrby("foo_hash1","k3",amount=-1)
print(r.hgetall("foo_hash1")) {'k3': '122', 'k2': 'v3', 'k1': 'v1'}
r.hincrby("foo_hash1","k4",amount=1) 不存在的话，value默认就是1
print(r.hgetall("foo_hash1")) {'k3': '122', 'k2': 'v3', 'k1': 'v1', 'k4': '4'}10 自增自减浮点数(将key对应的value--浮点数 自增1.0或者2.0，或者别的浮点数 负数就是自减)
hincrbyfloat(name, key, amount=1.0)
自增name对应的hash中的指定key的值，不存在则创建key=amount
参数：
name，redis中的name
key， hash对应的key
amount，自增数（浮点数）
自增name对应的hash中的指定key的值，不存在则创建key=amount
r.hset("foo_hash1","k5","1.0")
r.hincrbyfloat("foo_hash1","k5",amount=-1.0) 已经存在，递减-1.0
print(r.hgetall("foo_hash1"))
r.hincrbyfloat("foo_hash1","k6",amount=-1.0) 不存在，value初始值是-1.0 每次递减1.0
print(r.hgetall("foo_hash1")) {'k3': '122', 'k2': 'v3', 'k1': 'v1', 'k6': '-6', 'k5': '0', 'k4': '4'}11 取值查看--分片读取
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时，表示数据已经通过分片获取完毕
print(r.hscan("foo_hash1"))
(0L, {'k3': '122', 'k2': 'v3', 'k1': 'v1', 'k6': '-6', 'k5': '0', 'k4': '4'})12 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
print(r.hscan_iter("foo_hash1")) <generator object hscan_iter at 0x027B2C88> 生成器内存地址
for item in r.hscan_iter('foo_hash1'):
print item
('k3', '122')
('k2', 'v3')
('k1', 'v1')
('k6', '-6')
('k5', '0')
('k4', '4')

5 redis基本命令_list

import redis 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库pool = redis.ConnectionPool(host='192.168.19.130', port=6379)host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379r = redis.Redis(connection_pool=pool) 创建实例1 增加（类似于list的append，只是这里是从左边新增加）--没有就新建
lpush(name,values)
在name对应的list中添加元素，每个新的元素都添加到列表的最左边
如：
r.lpush('oo', 11,22,33)
保存顺序为: 33,22,11
扩展：
rpush(name, values) 表示从右向左操作
r.lpush("foo_list1",11,22) 从列表的左边，先添加11，后添加22
print(r.lrange("foo_list1",0,20))
['22', '11', '22', '11', '22', '11', '22', '11', '22', '11', '22', '11', '22', '11', '22', '11', '22', '11']
切片取出值，范围是索引号0-20
print(r.llen("foo_list1")) 18 长度是182 增加（从右边增加）--没有就新建
r.rpush("foo_list1",2,3,4) 在列表的右边，依次添加2,3,4
print(r.lrange("foo_list1",0,-1))
['22', '11', '22', '11', '22', '11', '22', '11', '22', '11', '22',
'11', '22', '11', '22', '11', '22', '11', '2', '3', '4']
切片取出值，范围是索引号0-最后一个元素
print(r.llen("foo_list1")) 21 列表长度是213 往已经有的name的列表的左边添加元素，没有的话无法创建
lpushx(name,value)
在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
更多：
rpushx(name, value) 表示从右向左操作
r.lpushx("foo_list2",1) 这里"foo_list2"不存在
print(r.lrange("foo_list2",0,-1)) []
print(r.llen("foo_list2")) 0r.lpushx("foo_list1",1) 这里"foo_list1"之前已经存在，往列表最左边添加一个元素，一次只能添加一个
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素
['1', '22', '11', '22', '11', '22', '11', '22', '11', '22',
'11', '22', '11', '22', '11', '22', '11', '22', '11', '2', '3', '4']
print(r.llen("foo_list1")) 22 列表长度是224 往已经有的name的列表的右边添加元素，没有的话无法创建
r.rpushx("foo_list1",1) 这里"foo_list1"之前已经存在，往列表最右边添加一个元素，一次只能添加一个
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素
['1', '22', '11', '22', '11', '22', '11', '22', '11', '22',
'11', '22', '11', '22', '11', '22', '11', '22', '11', '2', '3', '4','1']
print(r.llen("foo_list1")) 23 列表长度是235 新增（固定索引号位置插入元素）
linsert(name, where, refvalue, value))
在name对应的列表的某一个值前或后插入一个新值
参数：
name，redis的name
where，BEFORE或AFTER
refvalue，标杆值，即：在它前后插入数据
value，要插入的数据
r.linsert("foo_list1","before","22","33") 往列表中左边第一个出现的元素"22"前插入元素"33"
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素
['1', '33', '22', '11', '22', '11', '22', '11', '22',
'11', '22', '11', '22', '11', '22', '11', '22', '11', '22', '11', '2', '3', '4', '1']
print(r.llen("foo_list1")) 24 列表长度是246 修改（指定索引号进行修改）
r.lset(name, index, value)
对name对应的list中的某一个索引位置重新赋值
参数：
name，redis的name
index，list的索引位置
value，要设置的值
r.lset("foo_list1",4,44) 把索引号是4的元素修改成44
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素
print(r.llen("foo_list1")) 24 列表长度是247 删除（指定值进行删除）
r.lrem(name, value, num)
在name对应的list中删除指定的值
参数：
name，redis的name
value，要删除的值
num， num=0，删除列表中所有的指定值；
num=2,从前到后，删除2个； num=1,从前到后，删除左边第1个
num=-2,从后向前，删除2个
r.lrem("foo_list1","2",1) 将列表中左边第一次出现的"2"删除
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素
['1', '33', '22', '11', '44', '11', '22', '11', '22', '11', '22', '11',
'22', '11', '22', '11', '22', '11', '22', '11', '3', '4', '1']
print(r.llen("foo_list1")) 23 列表长度是23r.lrem("foo_list1","11",0) 将列表中所有的"11"删除
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素
['1', '33', '22', '44', '22', '22', '22', '22', '22', '22', '22', '3', '4', '1']
print(r.llen("foo_list1")) 14 列表长度是148 删除并返回
lpop(name)
在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
更多：
rpop(name) 表示从右向左操作
print(r.lpop("foo_list1")) 删除最左边的22，并且返回删除的值22
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素
['44', '22', '22', '22', '22', '22', '22', '22', '3', '4', '1']
print(r.llen("foo_list1")) 11 列表长度是11print(r.rpop("foo_list1")) 删除最右边的1，并且返回删除的值1
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素
['44', '22', '22', '22', '22', '22', '22', '22', '3', '4']
print(r.llen("foo_list1")) 10 列表长度是109 删除索引之外的值
ltrim(name, start, end)
在name对应的列表中移除没有在start-end索引之间的值
参数：
name，redis的name
start，索引的起始位置
end，索引结束位置
r.ltrim("foo_list1",0,8) 删除索引号是0-8之外的元素，值保留索引号是0-8的元素
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素（这里是包含最后一个元素的，是左闭右闭）
['44', '22', '22', '22', '22', '22', '22', '22', '3']10 取值（根据索引号取值）
lindex(name, index)
在name对应的列表中根据索引获取列表元素
print(r.lindex("foo_list1",0)) 44 取出索引号是0的值
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素（这里是包含最后一个元素的，是左闭右闭）
['44', '22', '22', '22', '22', '22', '22', '22', '3', '4']11 移动 元素从一个列表移动到另外一个列表
rpoplpush(src, dst)
从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
参数：
src，要取数据的列表的name
dst，要添加数据的列表的name
r.rpoplpush("foo_list1","foo_list2")
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素（这里是包含最后一个元素的，是左闭右闭）
['44', '22', '22', '22', '22', '22', '22']
print(r.lrange("foo_list2",0,-1)) 切片取出值，范围是索引号0-最后一个元素（这里是包含最后一个元素的，是左闭右闭）
['22', '3']12 移动 元素从一个列表移动到另外一个列表 可以设置超时
brpoplpush(src, dst, timeout=0)
从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
参数：
src，取出并要移除元素的列表对应的name
dst，要插入元素的列表对应的name
timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
r.brpoplpush("foo_list2","foo_list1",timeout=2)
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素（这里是包含最后一个元素的，是左闭右闭）
['22', '3', '44', '22', '22', '22', '22', '22', '22']
print(r.lrange("foo_list2",0,-1)) 切片取出值，范围是索引号0-最后一个元素（这里是包含最后一个元素的，是左闭右闭）
[]13 一次移除多个列表
blpop(keys, timeout)
将多个列表排列，按照从左到右去pop对应列表的元素
参数：
keys，redis的name的集合
timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
更多：
r.brpop(keys, timeout)，从右向左获取数据
r.blpop("foo_list1",timeout=2)
print(r.lrange("foo_list1",0,-1)) 切片取出值，范围是索引号0-最后一个元素（这里是包含最后一个元素的，是左闭右闭）
['22', '3', '44', '22', '22', '22', '22', '22', '22']
print(r.lrange("foo_list2",0,-1)) 切片取出值，范围是索引号0-最后一个元素（这里是包含最后一个元素的，是左闭右闭）14 自定义增量迭代
由于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('foo_list1'): ['3', '44', '22', '22', '22'] 遍历这个列表
print item

6 redis基本命令_set

import redis 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库pool = redis.ConnectionPool(host='192.168.19.130', port=6379)host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379r = redis.Redis(connection_pool=pool) 创建实例Set操作，Set集合就是不允许重复的列表1 新增
sadd(name,values)
name对应的集合中添加元素
r.sadd("foo_set1",33,44,55,66) 往集合中添加一个元素 11
print(r.smembers("foo_set1")) set(['11']) 获取集合中所有的成员
print(r.scard("foo_set1")) 1 集合的长度是1r.sadd("foo_set2",66,77) 往集合中添加2个元素 22,33
print(r.smembers("foo_set2")) set(['22',"33"]) 获取集合中所有的成员
print(r.scard("foo_set2")) 2 集合的长度是22 获取元素个数 类似于len
scard(name)
获取name对应的集合中元素个数3 获取集合中所有的成员
smembers(name)
获取name对应的集合的所有成员3-1 获取集合中所有的成员--元组形式
sscan(name, cursor=0, match=None, count=None)
print(r.sscan("foo_set1")) (0L, ['11', '22', '33', '55'])3-2 获取集合中所有的成员--迭代器的方式
sscan_iter(name, match=None, count=None)
同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大
for i in r.sscan_iter("foo_set1"):
print(i)4 差集
sdiff(keys, *args)
在第一个name对应的集合中且不在其他name对应的集合的元素集合
print(r.sdiff("foo_set1","foo_set2")) set(['11']) 在集合foo_set1但是不在集合foo_set2中
print(r.smembers("foo_set1")) set(['22',"11"]) 获取集合中所有的成员
print(r.smembers("foo_set2")) set(['22',"33"]) 获取集合中所有的成员5 差集--差集存在一个新的集合中
sdiffstore(dest, keys, *args)
获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中
r.sdiffstore("foo_set3","foo_set1","foo_set2")
print(r.smembers("foo_set1")) set(['22',"11"]) 获取集合1中所有的成员
print(r.smembers("foo_set2")) set(['22',"33"]) 获取集合2中所有的成员
print(r.smembers("foo_set3")) set(['11']) 获取集合3中所有的成员6 交集
sinter(keys, *args)
获取多一个name对应集合的交集
print(r.sinter("foo_set1","foo_set2")) set(['22']) 取2个集合的交集
print(r.smembers("foo_set1")) set(['22',"11"]) 获取集合1中所有的成员
print(r.smembers("foo_set2")) set(['22',"33"]) 获取集合2中所有的成员7 交集--交集存在一个新的集合中
sinterstore(dest, keys, *args)
获取多一个name对应集合的并集，再将其加入到dest对应的集合中
r.sinterstore("foo_set3","foo_set1","foo_set2")
print(r.smembers("foo_set1")) set(['22',"11"]) 获取集合1中所有的成员
print(r.smembers("foo_set2")) set(['22',"33"]) 获取集合2中所有的成员
print(r.smembers("foo_set3")) set(['22']) 获取集合3中所有的成员7-1 并集
sunion(keys, *args)
获取多个name对应的集合的并集
print(r.sunion("foo_set1","foo_set2")) set(['11', '22', '33', '77', '55', '66'])
print(r.smembers("foo_set1")) set(['11', '33', '22', '55']) 获取集合1中所有的成员
print(r.smembers("foo_set2")) set(['33', '77', '66', '22']) 获取集合2中所有的成员7-2 并集--并集存在一个新的集合
sunionstore(dest,keys, *args)
获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中
r.sunionstore("foo_bingji","foo_set1","foo_set2")
print(r.smembers("foo_set1")) set(['11', '33', '22', '55']) 获取集合1中所有的成员
print(r.smembers("foo_set2")) set(['33', '77', '66', '22']) 获取集合2中所有的成员
print(r.smembers("foo_bingji")) set(['11', '22', '33', '77', '55', '66'])8 判断是否是集合的成员 类似in
sismember(name, value)
检查value是否是name对应的集合的成员
print(r.sismember("foo_set1",11)) True 11是集合的成员
print(r.sismember("foo_set1","11")) True
print(r.sismember("foo_set1",23)) False 23不是集合的成员9 移动
smove(src, dst, value)
将某个成员从一个集合中移动到另外一个集合
r.smove("foo_set1","foo_set4",11)
print(r.smembers("foo_set1")) set(['22',"11"]) 获取集合1中所有的成员
print(r.smembers("foo_set4")) set(['22',"33"]) 获取集合4中所有的成员10 删除--随机删除并且返回被删除值
spop(name)
从集合移除一个成员，并将其返回,说明一下，集合是无序的，所有是随机删除的
print(r.smembers("foo_set1")) set(['11', '22', '33', '44', '55', '66']) 获取集合1中所有的成员
print(r.spop("foo_set1")) 44 （这个删除的值是随机删除的，集合是无序的）
print(r.smembers("foo_set1")) set(['11', '33', '66', '22', '55']) 获取集合1中所有的成员11 删除--指定值删除
srem(name, values)
在name对应的集合中删除某些值
print(r.smembers("foo_set1")) set(['11', '33', '66', '22', '55'])
r.srem("foo_set1",66) 从集合中删除指定值 66
print(r.smembers("foo_set1")) set(['11', '33', '22', '55'])12 随机获取多个集合的元素
srandmember(name, numbers)
从name对应的集合中随机获取 numbers 个元素
print(r.srandmember("foo_set1",3)) ['33', '55', '66'] 随机获取3个元素
print(r.smembers("foo_set1")) set(['11', '33', '66', '22', '55'])

07 redis基本命令_有序set

import redis 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库pool = redis.ConnectionPool(host='192.168.19.130', port=6379)
host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379r = redis.Redis(connection_pool=pool) 创建实例Set操作，Set集合就是不允许重复的列表，本身是无序的
有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，
所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。1 新增
zadd(name, *args, **kwargs)
在name对应的有序集合中添加元素
如：
zadd('zz', 'n1', 1, 'n2', 2)
或
zadd('zz', n1=11, n2=22)
r.zadd("foo_zset1",n3=11,n4=22)
r.zadd("foo_zset2",n3=11,n4=23)
print(r.zcard("foo_zset1")) 2 长度是2 2个元素
print(r.zrange("foo_zset1",0,-1)) ['n1', 'n2'] 获取有序集合中所有元素
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n1', 11.0), ('n2', 22.0)] 获取有序集合中所有元素和分数2 获取有序集合元素个数 类似于len
zcard(name)
获取name对应的有序集合元素的数量3 获取有序集合的所有元素
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)3-1 从大到小排序
zrevrange(name, start, end, withscores=False, score_cast_func=float)
print(r.zrevrange("foo_zset1",0,-1)) ['n2', 'n1'] 只获取元素，不显示分数
print(r.zrevrange("foo_zset1",0,-1,withscores=True)) [('n2', 22.0), ('n1', 11.0)]
获取有序集合中所有元素和分数,安装分数倒序3-2 按照分数范围获取name对应的有序集合的元素
zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
print(r.zrangebyscore("foo_zset1",15,25)) ['n2']
print(r.zrangebyscore("foo_zset1",12,22, withscores=True)) [('n2', 22.0)]
在分数是12-22之间（左闭右闭），取出符合条件的元素3-3 从大到小排序
zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
print(r.zrevrangebyscore("foo_zset1",22,11,withscores=True)) [('n2', 22.0), ('n1', 11.0)]
在分数是22-11之间（左闭右闭），取出符合条件的元素 按照分数倒序3-4 获取所有元素--默认按照分数顺序排序
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
print(r.zscan("foo_zset1")) (0L, [('n3', 11.0), ('n4', 22.0), ('n2', 30.0)])3-5 获取所有元素--迭代器
zscan_iter(name, match=None, count=None,score_cast_func=float)
for i in r.zscan_iter("foo_zset1"): 遍历迭代器
print(i)
('n3', 11.0)
('n4', 22.0)
('n2', 30.0)4 zcount(name, min, max)
获取name对应的有序集合中分数 在 [min,max] 之间的个数
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n1', 11.0), ('n2', 22.0)]
print(r.zcount("foo_zset1",11,22)) 25 自增
zincrby(name, value, amount)
自增name对应的有序集合的 name 对应的分数
r.zincrby("foo_zset1","n2",amount=2) 每次将n2的分数自增2
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n1', 11.0), ('n2', 30.0)]6 获取值的索引号
zrank(name, value)
获取某个值在 name对应的有序集合中的排行（从 0 开始）
更多：
zrevrank(name, value)，从大到小排序
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n1', 11.0), ('n2', 30.0)]
print(r.zrank("foo_zset1","n1")) 0 n1的索引号是0 这里按照分数顺序（从小到大）
print(r.zrank("foo_zset1","n2")) 1 n2的索引号是1print(r.zrevrank("foo_zset1","n1")) 1 n1的索引号是1 这里安照分数倒序（从大到小）7 删除--指定值删除
zrem(name, values)
删除name对应的有序集合中值是values的成员
如：zrem('zz', ['s1', 's2'])
print(r.zrange("foo_zset1",0,-1,withscores=True))
r.zrem("foo_zset2","n3") 删除有序集合中的元素n1 删除单个
print(r.zrange("foo_zset1",0,-1,withscores=True))8 删除--根据排行范围删除，按照索引号来删除
zremrangebyrank(name, min, max)
根据排行范围删除
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n3', 11.0), ('n4', 22.0), ('n2', 30.0)]
r.zremrangebyrank("foo_zset1",0,1) 删除有序集合中的索引号是0,1的元素
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n2', 30.0)]9 删除--根据分数范围删除
zremrangebyscore(name, min, max)
根据分数范围删除
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n3', 11.0), ('n4', 22.0), ('n2', 30.0)]
r.zremrangebyscore("foo_zset1",11,22) 删除有序集合中的分数是11-22的元素
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n2', 30.0)]10 获取值对应的分数
zscore(name, value)
获取name对应有序集合中 value 对应的分数
print(r.zrange("foo_zset1",0,-1,withscores=True)) [('n3', 11.0), ('n4', 22.0), ('n2', 30.0)]
print(r.zscore("foo_zset1","n3")) 11.0 获取元素n3对应的分数11.0import redis 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库pool = redis.ConnectionPool(host='192.168.19.130', port=6379)
host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379r = redis.Redis(connection_pool=pool) 创建实例

08 其他常用操作

1 删除
delete(*names)
根据删除redis中的任意数据类型（string、hash、list、set、有序set）1-1删除string
r.set('foo', 'Bar')
print(r.strlen("foo")) 3 3ge 字节
print(r.getrange("foo",0,-1)) Bar
r.delete("foo") 删除字符串类型的foo
print(r.get("foo")) None
print(r.getrange("foo",0,-1))
print(r.strlen("foo")) 0 0个字节1-2 删除hash
r.hset("foo_hash4","k1","v1")
print(r.hscan("foo_hash4")) (0L, {'k1': 'v1'})
r.delete("foo_hash4") 删除hash类型的键值对
print(r.hscan("foo_hash4")) (0L, {})2 检查名字是否存在
exists(name)
检测redis的name是否存在
print(r.exists("foo_hash4")) True 存在就是True
print(r.exists("foo_hash5")) False 不存在就是False2-1
r.lpush("foo_list5",11,22)
print(r.lrange("foo_list5",0,-1)) ['22', '11', '22', '11']
print(r.exists("foo_list5")) True 存在就是True
print(r.exists("foo_list6")) False 不存在就是False3 模糊匹配
keys(pattern='*')
根据模型获取redis的name
更多：
KEYS * 匹配数据库中所有 key 。
KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
KEYS h*llo 匹配 hllo 和 heeeeello 等。
KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
print(r.keys("foo*"))
['foo_hash1', 'foo_bingji', 'foo_list1', 'foo_list2', 'foo3', 'foo_set2', 'foo_hash4', 'foo_zset2',
'foo2', 'foo4', 'foo_set1', 'foo_zset1', 'foo_hash2', 'foo1', 'foo_list5', 'foo_set3']4 设置超时时间
expire(name ,time)
为某个redis的某个name设置超时时间
r.lpush("foo_list5",11,22)
r.expire("foo_list5",time=10)
print(r.lrange("foo_list5",0,-1))5 重命名
rename(src, dst)
对redis的name重命名为
r.rename("foo_list6","foo_list5")
print(r.lrange("foo_list5",0,-1)) ['22', '11']
print(r.lrange("foo_list6",0,-1)) []6 随机获取name
randomkey()
随机获取一个redis的name（不删除）
print(r.keys("foo*"))
['foo_set1', 'foo3', 'foo_set2', 'foo_zset2', 'foo4', 'foo_zset1', 'foo_list5', 'foo2',
'foo_hash2', 'foo1', 'foo_set3', 'foo_hash1', 'foo_hash4', 'foo_list2', 'foo_bingji']
print(r.randomkey()) foo_hash2 随机获取一个name7 获取类型
type(name)
获取name对应值的类型
print(r.type("foo_hash2")) hash
print(r.type("foo_set1")) set
print(r.type("foo3")) string8 查看所有元素
scan(cursor=0, match=None, count=None)
print(r.hscan("foo_hash2")) (0L, {'k3': 'v3', 'k2': 'v2'})
print(r.sscan("foo_set3")) (0L, ['22'])
print(r.zscan("foo_zset2")) (0L, [('n4', 23.0)])
print(r.getrange("foo1",0,-1)) 121 --字符串
print(r.lrange("foo_list5",0,-1)) ['22', '11'] --列表9 查看所有元素--迭代器
scan_iter(match=None, count=None)
for i in r.hscan_iter("foo_hash2"):--遍历
print(i)
('k3', 'v3')
('k2', 'v2')for i in r.sscan_iter("foo_set3"):
print(i) 22for i in r.zscan_iter("foo_zset2"):
print(i) ('n4', 23.0)__author__ = 'Administrator'
-*- coding:utf-8 -*-管道
redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，
如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。import redispool = redis.ConnectionPool(host='192.168.19.130', port=6379)r = redis.Redis(connection_pool=pool)pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)r.set('name', 'jack')
r.set('role', 'sb')pipe.execute()print(r.get("name")) jack
print(r.get("role")) sb