Python 11：RabbitMQ、redis

Python 11：RabbitMQ、redis

---

1、RabbitMQ

2、缓存数据库：redis

---

 一、RabbitMQ

 1、基本信息

市面上的MQ：rabbitMQ、ZeroMQ、ActiveMQ 

rabbitMQ是基于erlang 开发的安装前需要先装环境，默认端口5672

2、简单通信

import pika
connection = pika.BlockingConnection(
    pika.ConnectionParameters('localhost'))
channel = connection.channel()          #声明一个管道
#声明queue
channel.queue_declare(queue='hello')
channel.basic_publish(exchange='',
                      routing_key='hello',    #queue 名字
                      body='Hello World!')  #消息内容
print(" [x] Sent 'Hello World!'")
connection.close()

import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
'''
已经在produce里声明队列了，为什么这里还要再次声明？
如果你确认这个queue已经确实被声明过了，那就可以不写
但是我们不确认是send先运行还是receive先运行
所以在这里再次声明一下，如果先前已经声明过了，这里就会pass，如果没有声明，这里就会起到声明queue的作用
'''
channel.queue_declare(queue='hello')   #再次声明队列
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag) #与发送方确认收到消息（参考no_ack = True）
channel.basic_consume(    #消费消息
                      callback,   #如果收到消息就调用callback函数处理消息
                      queue='hello',
                      no_ack=True)  #no ackownledgement   #不确认消息，接收端无论是否收到消息都不与发送端确认
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

在这种模式下，RabbitMQ会默认把send发的消息依次分发给各个receive，跟负载均衡差不多 

3、消息的持久化

channel.queue_declare(queue='hello', durable=True)

发送方接收方管道都要加上：durable=True参数，作用：持久化queue，rabbitMQ宕机后queue仍会存在，但是消息会丢失

channel.basic_publish(exchange='',routing_key="task_queue",body=message,properties=pika.BasicProperties(delivery_mode = 2,))

在发送消息端加上：properties参数：properties=pika.BasicProperties(delivery_mode= 2，）

其中：delivery_mode= 2 就表示把queue中的消息持久化

4、消息公平分发

如果Rabbit只管按顺序把消息发到各个消费者身上，不考虑消费者负载的话，很可能出现，一个机器配置不高的消费者那里堆积了很多消息处理不完，同时配置高的消费者却一直很轻松。为解决此问题，可以在各个消费者端，配置perfetch=1,意思就是告诉RabbitMQ在我这个消费者当前消息还没处理完的时候就不要再给我发新消息了。

channel.basic_qos(prefetch_count=1)


import pika
import sys 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel() 
channel.queue_declare(queue='task_queue', durable=True) 
message = ' '.join(sys.argv[1:]) or "Hello World!"
channel.basic_publish(exchange='',routing_key='task_queue', body=message,properties=pika.BasicProperties(delivery_mode = 2,))
print(" [x] Sent %r" % message)
connection.close()

import pika
import time
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel() 
channel.queue_declare(queue='task_queue', durable=True)
print(' [*] Waiting for messages. To exit press CTRL+C') 
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    time.sleep(body.count(b'.'))
    print(" [x] Done")
    ch.basic_ack(delivery_tag = method.delivery_tag) 
channel.basic_qos(prefetch_count=1)
channel.basic_consume(callback,queue='task_queue') 
channel.start_consuming()

5、广播

Exchange相当于一个转发器，消息发送给MQ，其实就是发送给了exchange，在定义的时候是有类型的，以决定到底是哪些Queue符合条件，可以接收消息

fanout: 所有bind到此exchange的queue都可以接收消息

direct: 通过routingKey和exchange决定的那个唯一的queue可以接收消息

topic:所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息

headers: 通过headers 来决定把消息发给哪些queue

1、fanout：接受所有消息

import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
#在producer和consumer中分别声明一次以保证所要使用的exchange存在
channel.exchange_declare(exchange='logs',exchange_type= 'fanout')
message = ' '.join(sys.argv[1:]) or "info: Hello World!"
channel.basic_publish(exchange='logs',routing_key='',body=message)
print(" [x] Sent %r" % message)
connection.close()

import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs',exchange_type='fanout') #在send和receive中分别声明一次以保证所要使用的exchange存在
#在不同的send和receive间共享queue时指明queue的name是重要的
#但某些时候，比如日志系统，需要接收所有的log message而非一个子集
#而且仅对当前的message 流感兴趣，对于过时的message不感兴趣，那么
#可以申请一个临时队列这样，每次连接到RabbitMQ时会以一个随机的名字生成
#一个新的空的queue，将exclusive置为True，这样在consumer从RabbitMQ断开后会删除该queue
result = channel.queue_declare(exclusive=True) #不指定queue名字,rabbit会随机分配一个名字,exclusive=True会在使用此queue的消费者断开后,自动将queue删除
queue_name = result.method.queue  #用于获取临时queue的name
channel.queue_bind(exchange='logs',queue=queue_name)
#exchange与queue之间的关系成为binding
#binding告诉exchange将message发送该哪些queue
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
    print(" [x] %r" % body)
 #从指定地queue中consume message且不确认
channel.basic_consume(callback,queue=queue_name,no_ack=True)
channel.start_consuming()

TypeError: exchange_declare() got an unexpected keyword argument 'type'问题

解决办法：pika版本不同导致的用法不同，把type换成exchange_type

2、direct：有选择的接受消息(exchange_type=direct)　 

import pika
import sys 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel() 
channel.exchange_declare(exchange='direct_logs',exchange_type='direct') 
severity = sys.argv[1] if len(sys.argv) > 1 else 'info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='direct_logs',routing_key=severity,body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()

import pika
import sys
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='direct_logs',exchange_type='direct')
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
severities = sys.argv[1:]
if not severities:
    sys.stderr.write("Usage: %s [info] [warning] [error]
" % sys.argv[0])
    sys.exit(1)
for severity in severities:
    channel.queue_bind(exchange='direct_logs',queue=queue_name,routing_key=severity)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))
channel.basic_consume(callback,queue=queue_name,no_ack=True)
channel.start_consuming()

接收端启动必须带参数：python receive.py info warning

3、topic：更细致的消息过滤

import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='topic_logs',exchange_type='topic')
routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='topic_logs', routing_key=routing_key,body=message)
print(" [x] Sent %r:%r" % (routing_key, message))
connection.close()

import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='topic_logs',exchange_type='topic')
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
binding_keys = sys.argv[1:]
if not binding_keys:
    sys.stderr.write("Usage: %s [binding_key]...
" % sys.argv[0])
    sys.exit(1)
for binding_key in binding_keys:
    channel.queue_bind(exchange='topic_logs',queue=queue_name,routing_key=binding_key)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))
channel.basic_consume(callback,queue=queue_name,no_ack=True)
channel.start_consuming()

接收端启动必须带参数：python receive.py info *.warning *.rabbit 

6、rpc（Remote procedure call） 

import pika
import time
connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost')) 
channel = connection.channel() 
channel.queue_declare(queue='rpc_queue') 
def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2) 
def on_request(ch, method, props, body):
    n = int(body) 
    print(" [.] fib(%s)" % n)
    response = fib(n) 
    ch.basic_publish(exchange='',
                     routing_key=props.reply_to,
                     properties=pika.BasicProperties(correlation_id = 
                                                         props.correlation_id),
                     body=str(response))
    ch.basic_ack(delivery_tag = method.delivery_tag) 
channel.basic_qos(prefetch_count=1)
channel.basic_consume(on_request, queue='rpc_queue') 
print(" [x] Awaiting RPC requests")
channel.start_consuming()

import pika
import uuid 
class FibonacciRpcClient(object):
    def __init__(self):
        self.connection = pika.BlockingConnection(pika.ConnectionParameters(
                host='localhost')) 
        self.channel = self.connection.channel() 
        result = self.channel.queue_declare(exclusive=True)
        self.callback_queue = result.method.queue 
        self.channel.basic_consume(self.on_response, no_ack=True,
                                   queue=self.callback_queue) 
    def on_response(self, ch, method, props, body):
        if self.corr_id == props.correlation_id:
            self.response = body 
    def call(self, n):
        self.response = None
        self.corr_id = str(uuid.uuid4())
        self.channel.basic_publish(exchange='',
                                   routing_key='rpc_queue',
                                   properties=pika.BasicProperties(
                                         reply_to = self.callback_queue,
                                         correlation_id = self.corr_id,
                                         ),
                                   body=str(n))
        while self.response is None:
            self.connection.process_data_events()
        return int(self.response) 
fibonacci_rpc = FibonacciRpcClient() 
print(" [x] Requesting fib(30)")
response = fibonacci_rpc.call(30)
print(" [.] Got %r" % response)

二、缓存数据库：redis

1、介绍

 NoSQL(NoSQL = Not Only SQL )，泛指非关系型的数据库，NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

NoSQL数据库在以下的这几种情况下比较适用：

1、数据模型比较简单；

2、需要灵活性更强的IT系统；

3、对数据库性能要求较高；

4、不需要高度的数据一致性；

5、对于给定key，比较容易映射复杂值的环境。

 2、分类

分类	举例	应用场景	数据模型	优点	缺点
键值（key-value）	Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB	内容缓存，主要用于处理大量数据的高访问负载，也用于一些日志系统等等	Key 指向 Value 的键值对，通常用hash table来实现	查找速度快	数据无结构化，通常只被当作字符串或者二进制数据
列存储数据库	Cassandra, HBase, Riak	分布式的文件系统	以列簇式存储，将同一列数据存在一起	查找速度快，可扩展性强，更容易进行分布式扩展	功能相对局限
文档型数据库	CouchDB, MongoDb	Web应用（与Key-Value类似，Value是结构化的，不同的是数据库能够了解Value的内容）	Key-Value对应的键值对，Value为结构化数据	数据结构要求不严格，表结构可变，不需要像关系型数据库一样需要预先定义表结构	查询性能不高，而且缺乏统一的查询语法。
图形(Graph)数据库	Neo4J, InfoGrid, Infinite Graph	社交网络，推荐系统等。专注于构建关系图谱	图结构	利用图结构相关算法。比如最短路径寻址，N度关系查找等	很多时候需要对整个图做计算才能得出需要的信息，而且这种结构不太好做分布式的集群方案。

 

 

 

3、redis介绍

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

Redis优点

1、异常快速 :因为数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)

2、支持丰富的数据类型 : Redis支持最大多数开发人员已经知道如列表，集合，可排序集合，哈希等数据类型。

3、操作都是原子的 :所谓的原子性就是对数据的更改要么全部执行，要么全部不执行。

4、丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除

4、redis使用Python链接

import redis 
r = redis.Redis(host='localhost', port=6379)
r.set('key', 'value')
print r.get('key')

import redis 
pool = redis.ConnectionPool(host='localhost', port=6379) 
r = redis.Redis(connection_pool=pool)
r.set('key', 'value')
print r.get('key')

5、String操作

redis中的String在在内存中按照一个name对应一个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, value, time)
'''设置值、参数、time：过期时间（数字秒 或 timedelta对象）'''

#psetex(name, time_ms, value)
'''设置值、参数、time_ms，过期时间（数字毫秒 或 timedelta对象）'''

#mset(*args, **kwargs)
'''批量设置值：
        mset(k1='v1', k2='v2')
        mget({'k1': 'v1', 'k2': 'v2'})'''

#get(name)    获取值

#mget(keys, *args)
'''批量获取
        mget('ylr', 'wupeiqi')
        r.mget(['ylr', 'wupeiqi'])'''

#getset(name, value)    设置新值并获取原来的值

#getrange(key, start, end)
''' 获取子序列（根据字节获取，非字符）
    参数：
    name，Redis 的 name
    start，起始位置（字节）
    end，结束位置（字节）
'''
# setrange(name, offset, value)
'''修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
    参数：
        offset，字符串的索引，字节（一个汉字三个字节）
        value，要设置的值'''

# strlen(name)
'''返回name对应值的字节长度（一个汉字3个字节）'''

# incr(self, name, amount=1)
'''自增 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)
'''自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
    参数：
        name,Redis的name
        amount,自减数（整数）'''

# append(key, value)
'''在redis name对应的值后面追加内容
    参数：
        key, redis的name
        value, 要追加的字符串'''


# setbit(name, offset, value)
'''(对name对应值的二进制表示的位进行操作
    参数：
        name，redis的name
        offset，位的索引（将值变换成二进制后再进行索引）
        value，值只能是 1 或 0)'''

# getbit(name, offset)
'''(获取name对应的值的二进制表示中的某位的值 （0或1）)'''

# bitcount(key, start=None, end=None)
'''(获取name对应的值的二进制表示中 1 的个数
    参数：
        key，Redis的name
        start，位起始位置
        end，位结束位置)
'''
import redis
r = redis.Redis(host='localhost', port=6379)
r.set('n1', 'abc')
ord("a")   #97
print(bin(97))   #0b1100001
r.setbit("n1",6,1)  #把二进制的第六为改为1， a>c
print(r.get("n1"))  #b'cbc'

print(r.getbit("n1",5))  #0 获取第5位的值

print(r.bitcount("n1"))  # 11  "cbc"对应的二进制中有多少个1

#应用：用最省空间的方式，存储在线用户数及分别是哪些用户在线

6、Hash操作

hash表现形式上有些像pyhton中的dict,可以存储一组关联性较强的数据 

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

7、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, num, value)
'''在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 表示永远阻塞'''

8、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)，从大到小排序'''
# zrem(name, values)
'''删除name对应的有序集合中值是values的成员
    如：zrem('zz', ['s1', 's2'])'''
# zremrangebyrank(name, min, max)
'''根据排行范围删除'''
# zremrangebyscore(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，用来对分数进行操作'''

9、其他常用操作 

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

10、管道

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

import redis

pool = redis.ConnectionPool(host='localhost', port=6379)
r = redis.Redis(connection_pool=pool)
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
pipe.set('n1', 'aaa')
pipe.set('n2', 'bbb')

pipe.execute()