python操作rabbitmq、redis

1.启动rabbimq、mysql

在“”运行“”里输入services.msc，找到rabbimq、mysql启动即可

2.启动redis

管理员进入cmd，进入redis所在目录，执行redis-server.exe redis.windows.conf --maxmemory 200M  启动redis  server

执行redis-cli.exe启动客户端

一、 python系列之 RabbitMQ - hello world

介绍

python连接远程rabbitmq代码：

1 import pika
2 import sys
3
4 username = 'wt'  #rabbitmq用户名
5 pwd = '111111'  #rabbitmq密码
6 user_pwd = pika.PlainCredentials(username, pwd)
7 s_conn = pika.BlockingConnection(pika.ConnectionParameters('192.168.1.240', credentials=user_pwd))
8 chan = s_conn.channel()
9 print('hello')

或者 ：

1. credentials = pika.PlainCredentials('guest', 'geust')
2. #这里可以连接远程IP，请记得打开远程端口
3. parameters = pika.ConnectionParameters('localhost',5672,'/',credentials)
4. connection = pika.BlockingConnection(parameters)
5. channel = connection.channel()

 RabbitMQ 是一个消息中间件，它的主要功能非常简单:  接收和转发消息。  你可以认为 RabbitMQ 就是一个邮局，当你将邮件投递到邮箱后你非常确认邮递员会将你邮件最终投递到你的接收者。 通过这个比喻，MQ就是一个邮箱、邮局和邮递员  RabbitMQ与邮局的最大不同点是 MQ不处理纸张，而是存储和转发二进制数据(消息)

 

RabbitMQ有一些基本术语：  Producer（生产者）： 一个程序/应用 发送消息就是一个producer, 以下我们简称为 "P" 

Queue（队列）：queue就是一个"邮箱"的简称，它存在于RabbitMQ内部。虽然消息在RabbitMQ和你的应用之间传输，但他们只能保存在一 个队列(queue)里面。队列是不受任何限制的约束，你可以想存多少就存多少 - 它本质上是一个无限的缓冲区。

Consumer（消费者）：类似一个接收者, 一个 Consumer 是一个等待接收消息的程序，以下我们简称 “C"

 

注意： 一个Producer、Consuer和中间件（MQ)不一定必须在同一台机器上，现实使用也是这样

 

Hello World

 (使用官方推荐的 pika python 客户端） 

 “hello world”这里并不复杂-- 我们发送一个消息、接收消息然后输出到屏幕，为了演示这个我们需要两个程序，一个发送、一个接收并打印 我们的设计如下图： 

1. 我们这里讲的RabbitMQ采用的是AMQP 0.9.1 ,一个开放的、通用的消息协议，在不同的语言中有很多的不同的RabbitMQ客户端，我们下面使用的是pika， 这个是RabbitMQ小组推荐的python客户端

Sending：

我们的第一个程序是send.py 用来发送消息到队列，第一件事就是要建立一个RabbitMQ的连接到Server端

1. import pika
2. s_connec = pika.BlockingConnection(pika.ConnectionParameters('loaclhost'))
3. chan = s_connec.channel()

我们现在就建立了连接了，由于我们中间件在本机所以这里的设置的是“localhost",如果我们想连接到一个不同的服务器，只 需要简单的将”localhost" 改为 服务器的主机名或IP地址.

下一步，在发送消息之前我们要确定接收队列存在，如果我们发送一个消息到一个不存在的目的地，RabbitMQ将丢弃这条消息， 我们先创建一个消息发送的目的队列，这里命名为 "hello"

1. chan.queue_declare(queue='hello')

到这点我们就可以发送一个消息了，我们的第一个消息将正式包含一个字符串“hello world"，将这个消息发送到 ”hello“队列 在RabbitMQ中，一个消息不能直接发送到一个队列中，通常需要通过一个交换（exchange），我们在后面的部分将详细讲解 exchange ，现在所有我们需要知道的是如何利用一个空字符串标识默认的exchange。这个一个特殊的exchange -- 它使我们能够确切地指定消息应该到哪个队列去。 这里需要在 routing_key 参数中指定发送的队列名：

1. chan.basic_publish(exchange="",
2. routing_key='hello',
3. body="hello world")
4. print(" [x] Sent 'Hello World!'")

在我们退出应用程序之前，我们需要确认网络缓冲区已经flush而且消息已经确认发送到了RabbitMQ中，我们可以使用下面的代码来关闭连接

1. s_connec.close()

 

Receiving

我们的第二个程序 receive.py 将从队列中接收消息并输出到屏幕 同样我们的第一步也是连接到RabbitMQ服务器，代码和服务端的一样：

1. connection = pika.BlockingConnection(pika.ConnectionParameters(
2. host='localhost'))
3. channel = connection.channel()

下一步和之前一样也需要确认队列是否存在，使用 queue_declare 创建一个队列。 你可能会问为什么还需要在创建一次队列，我们在上面的代码中已经创建了一次了。因为我们不能确认队列是否已经存在了，如果我们的服务端还未启动，队列也就没有创建，这个时候客户端启动了，就找不到队列。为了避免这个问题就需要在客户端和服务端均创建一下，这样就能保证无论是服务端还是客户端先启动队列都存在

1. channel.queue_declare(queue='hello')

1. 可以在服务器上通过执行以下命令查看队列信息
2. $ sudo rabbitmqctl list_queues

 

从队列接收消息要更复杂一些，它需要为队列订阅一个 callback 函数来进行接收。当我们接收一个消息后，这个 callback 函数将会被 pika函数库自动调用， 在我们的这个实例里面这个函数将用来打印接收的消息内容到屏幕

1. def callback(ch, method, properties, body):
2. print(" [x] Received %r" % body)

下一步我们需要告诉RabbitMQ这个特殊的 callback 函数需要从我们的hello队列接收消息

1. channel.basic_consume(callback,
2. queue='hello',
3. no_ack=True)

no_ack 参数将在后面的部分讲解

最终，我们执行永不停止的循环来等待数据和调用callbacks进行数据处理 

1. print(' [*] Waiting for messages. To exit press CTRL+C')
2. channel.start_consuming()

 

完整代码：

Producer： send.py

1. import pika
2. connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
3. channel = connection.channel()
4. channel.queue_declare(queue='hello')
5. channel.basic_publish(exchange='',
6. routing_key='hello',
7. body='Hello World!')
8. print(" [x] Sent 'Hello World!'")
9. connection.close()

Consumer：receive.py

1. import pika
2. def callback(ch, method, properties, body):
3. print(" [x] Received %r" % body)
4. connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
5. channel = connection.channel()
6. channel.queue_declare(queue='hello')
7. channel.basic_consume(callback,
8. queue='hello',
9. no_ack=True)
10. print(' [*] Waiting for messages. To exit press CTRL+C')
11. channel.start_consuming()

二、python系列之 RabbitMQ - work queues

本节我们创建一个工作队列( work queue )用来在多个workers之间分发消息

工作队列(又名：任务队列)的主要思想是避免在资源密集型的任务处理中不得不等待它的完成，相反，我们安排这个任务稍后完成。我们把这任务作为一个消息封装起来并发送到一个队列中，一个后台工作进程将这个任务取出并最终执行这个任务，当你运行多个任务时，多个消费者将共享这些任务。

这个概念在网页应用中对于在HTTP短连接请求中处理复杂任务时尤其有用。

 

预备

前面的部分我们发送了一个消息内容“hello world", 现在我们要发送复杂任务的字符串。我们没有真实世界的任务，比如重新调整一个图片大小或者渲染一个PDF文件，我们通过time.sleep()函数假装消息接收后任务非常繁忙，需要消耗一定的时间，我们通过字符串中小数点的个数来描述任务的复杂性，每个点代表“work"要耗费1秒,例如：假设一个任务描述 "Hello..." 将要耗费3秒钟。

 

我们修改之前的 send.py 代码，允许通过命令行来发送任意消息。这个程序将要处理任务到工作队列。我们命名为 new_task.py

1. import pika
2. import sys
3. message = ' '.join(sys.argv[1:]) or "Hello World"
4. channel.basic_publish(exchange='',
5. routing_key='worker',
6. body=message,
7. properties=pika.BasicProperties(delivery_mode = 2,)
8. )
9. print(" [x] Send %r " % message)

 

之前老的 receive.py 脚本也需要一些改变,我们对处理模块 callback 函数进行一些修改：它假装对消息中的每个小数点需要1秒时间进行处理，它将会从消息队列中pop一个消息然后执行任务，我们用 worker.py 来命名这个文件

1. import time
2. def callback(ch, method, properties, body):
3. print(" [x] Received %r" % body)
4. time.sleep(body.count(b'.'))
5. print(" [x] Done")
6. ch.basic_ack(delivery_tag = method.delivery_tag)

循环调度(Round-robin dispatching)

使用任务队列（tack queue）的优点是很容易的进行并行工作的能力，如果我们的工作队列产生一定的积压，我们可以创建多个worker来接收并处理消息，这样很容易扩展

首先，我们试着同时运行两个worker.py 脚本，它们都可以从消息队列中获取消息，你需要开启两个终端，运行两个 worker.py ， 当做两个Consumer： C1 和 C2

1. shell1$ python worker.py
2. [*] Waiting for messages. To exit press CTRL+C

1. shell2$ python worker.py
2. [*] Waiting for messages. To exit press CTRL+C

再打开一个终端，运行 new_task.py ，执行多个任务

1. shell3$ python new_task.py First message.
2. shell3$ python new_task.py Second message..
3. shell3$ python new_task.py Third message...
4. shell3$ python new_task.py Fourth message....
5. shell3$ python new_task.py Fifth message.....

 

让我们看看两个worker端接收的消息：

1. shell1$ python worker.py
2. [*] Waiting for messages. To exit press CTRL+C
3. [x] Received 'First message.'
4. [x] Received 'Third message...'
5. [x] Received 'Fifth message.....'

1. shell2$ python worker.py
2. [*] Waiting for messages. To exit press CTRL+C
3. [x] Received 'Second message..'
4. [x] Received 'Fourth message....'

 

默认，RabbitMQ将循环的发送每个消息到下一个Consumer , 平均每个Consumer都会收到同样数量的消息。 这种分发消息的方式成为 循环调度（round-robin)

 

上述完整代码

new_task.py

1. import pika
2. import sys
3. connec = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
4. channel = connec.channel()
5. channel.queue_declare(queue='worker')
6. message = ' '.join(sys.argv[1:]) or "Hello World"
7. channel.basic_publish(exchange='',
8. routing_key='worker',
9. body=message,
10. properties=pika.BasicProperties(delivery_mode = 2,)
11. )
12. print(" [x] Send %r " % message)

 

worker.py

1. import time
2. import pika
3. connect = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
4. channel = connect.channel()
5. channel.queue_declare('worker')
6. def callback(ch, method, properties,body):
7. print(" [x] Received %r" % body)
8. time.sleep(body.count(b'.'))
9. print(" [x] Done")
10. ch.basic_ack(delivery_tag = method.delivery_tag)
11. channel.basic_consume(callback,
12. queue='worker',
13. )
14. channel.start_consuming()

消息确认（Message acknowledgment)

 

执行一个任务能消耗几秒. 你可能想知道当一个consumer在执行一个艰巨任务或执行到一半是死掉了会发生什么。就我们当前的代码而言,一旦RabbitMQ 的分发完消息给 consumer后 就立即从内存中移除该消息。这样的话，如果一个worker刚启动你就结束掉，那么消息就丢失了。那么所有发送给这个 worker 的还没有处理完成的消息也将丢失。

但是我们不想丢失任何任务，如果worker死掉了，我们希望这个任务能够发送给其它的worker

为了确保一个消息不会丢失，RabbitMQ支持消息的 acknowlegements , 一个 ack(nowlegement) 是从consumer端发送一个回执去告诉RabbitMQ 消息已经接收了、处理了，RabbitMQ可以释放并删除掉了。

如果一个consumer 死掉了（channel关闭、connection关闭、或者TCP连接断开了）而没有发送ack，RabbitMQ 就会知道这个消息没有被完全处理并会重新发送到消息队列中，如果同时有另外一个consumer在线，将会很快转发到另外一个consumer中。 那样的话你就能确保虽然worker死掉，但消息不会丢失。

这个是没有超时的，当消费方（consumer）死掉后RabbitMQ会重新转发消息，即使处理这个消息需要很长很长时间也没有问题

消息的 acknowlegments 默认是打开的，在前面的例子中关闭了： no_ack = True . 现在删除这个标识 然后 发送一个 acknowledgment。

1. def callback(ch, method, properties, body):
2. print " [x] Received %r" % (body,)
3. time.sleep( body.count('.') )
4. print " [x] Done"
5. ch.basic_ack(delivery_tag = method.delivery_tag)
6. channel.basic_consume(callback,
7. queue='hello')

使用这个代码我们能确保即使在程序运行中使用CTRL+C结束worker进程也不会有消息丢失。之后当worker死掉之后所有未确认的消息将会重新进行转发。

 

1. 忘了 acknowlegement
2. 忘记设置basic_ack是一个经常犯也很容易犯的错误，但后果是很严重的。当客户端退出后消息将会重新转发，但RabbitMQ会因为不能释放那些没有回复的消息而消耗越来越多的内存
3. 为了调试(debug)这种类型的错误，你可以使用 rabbitmqctl 打印 message_unacknowledged 字段：
4. $ sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged
5. Listing queues ...
6. hello    0       0
7. ...done

 

消息持久化（Message durability)

我们已经学习了即使客户端死掉了任务也不会丢失。但是如果RabbitMQ服务停止了的话，我们的任务还是会丢失。

当RabbitMQ退出或宕掉的话将会丢失queues和消息信息，除非你进行设置告诉服务器队列不能丢失。要确保消息不会丢失需要做两件事： 我们需要将队列和消息标记为 durable

首先：

我们需要确保RabbitMQ 永远不会丢失队列，为了确保这个，我们需要定义队列为durable：

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

尽管此命令本身定义是正确的，但我们设置后还是不会工作。因为我们已经定义了个名为 hello ，但不是durable属性的队列。RabbitMQ不允许你重新定义一个已经存在、但属性不同的queue。RabbitMQ 将会给定义这个属性的程序返回一个错误。但这里有一个快速的解决方法：让我们定义个不同名称的队列，比如 task_queue:

1. channel.queue_declare(queue='task_queue', durable=True)

这个 queue_declare 需要在 生产者（producer） 和消费方（consumer) 代码中都进行设置。

基于这一点, 我们能够确保 task_queue 队列即使RabbitMQ重启也不会丢失

 

现在我们需要标记我们的消息为持久化的 - 通过设置 delivery_mode 属性为 2

1. channel.basic_publish(exchange='',
2. routing_key="task_queue",
3. body=message,
4. properties=pika.BasicProperties(
5. delivery_mode = 2, # make message persistent
6. ))

 

消息持久化的注意点

标记消息为持久化的并不能完全保证消息不会丢失，尽管告诉RabbitMQ保存消息到磁盘，当RabbitMQ接收到消息还没有保存的时候仍然有一个短暂的时间窗口. RabbitMQ不会对每个消息都执行同步fsync(2) --- 可能只是保存到缓存cache还没有写入到磁盘中，这个持久化保证不是很强，但这比我们简单的任务queue要好很多，如果你想很强的保证你可以使用 publisher confirms

公平调度（Fair dispatch）

你可能已经注意到分发仍然不能完全符合我们想要进行的工作。比如有两个worker的一种情况，当所有基数的消息比较重要，偶数的消息相对不重要，一个worker相对处理比较繁忙而另一个几乎不怎么工作。但是对于RabbitMQ而言，它对此一无所知并仍然均匀的分发消息。

发生这样的情况是由于RabbitMQ只是当消息来是进行分发，它并不考虑消费方（consuer）回复的ack消息，它只是一味地分发每个消息到各个消费方

为了解决这个问题我们可以使用 basic.qos 方法使用 prefetch_count = 1 设置， 这样告诉RabbitMQ不要同时将多条消息分发到一个worker， 换句话说，在一个worker未处理完之前的消息之前不要分发新的消息给它。 换言之，会将这个消息分发给另一个不是很忙的worker进行处理。

1. channel.basic_qos(prefetch_count=1)

代码汇总

new_task.py 脚本的全部代码为：

1. import pika
2. import sys
3. connection = pika.BlockingConnection(pika.ConnectionParameters(
4. host='localhost'))
5. channel = connection.channel()
6. channel.queue_declare(queue='task_queue', durable=True) # 设置队列为持久化的队列
7. message = ' '.join(sys.argv[1:]) or "Hello World!"
8. channel.basic_publish(exchange='',
9. routing_key='task_queue',
10. body=message,
11. properties=pika.BasicProperties(
12. delivery_mode = 2, # 设置消息为持久化的
13. ))
14. print(" [x] Sent %r" % message)
15. connection.close()

new_task.py 脚本

1. #!/usr/bin/env python
2. import pika
3. import time
4. connection = pika.BlockingConnection(pika.ConnectionParameters(
5. host='localhost'))
6. channel = connection.channel()
7. channel.queue_declare(queue='task_queue', durable=True)  # 设置队列持久化
8. print(' [*] Waiting for messages. To exit press CTRL+C')
9. def callback(ch, method, properties, body):
10. print(" [x] Received %r" % body)
11. time.sleep(body.count(b'.'))
12. print(" [x] Done")
13. ch.basic_ack(delivery_tag = method.delivery_tag)
14. channel.basic_qos(prefetch_count=1)   # 消息未处理完前不要发送信息的消息
15. channel.basic_consume(callback,
16. queue='task_queue')
17. channel.start_consuming()

二、 python系列之 RabbitMQ -- Publish/Subscribe

前面的部分我们创建了一个工作队列（work queue）. 设想是每个任务都能分发到一个worker，这一部分我们将会做一些完全不同的事情 -- 我们将会分发一个消息到多个消费方（consumer），这种模式被誉为发布/订阅（publish/subscribe）模式

为了阐明这种模式,我们将要创建一个简单的日志系统，由两部分程序组成 -- 第一部分将要发布日志消息，第二部分接收并打印

在我们的日志系统中每个接收程序（receiver）将接收消息并复制消息内容，这样我们将会运行一个receiver  记录日志到磁盘；与此同时我们运行另一个receiver输入日志到屏幕查看。

本质上，发布日志消息将会广播到所有的receivers

交换 (Exchanges)

 

在前面的部分我们从一个队列来回发送并接收消息。现在介绍Rabbit中的完整消息模式。

让我们迅速回顾一下前面的章节的内容：

>>  一个 Producer 是一个发送消息的用户程序

>> 一个 queue 是一个存储消息的缓冲区

>> 一个 Consumer 是一个接收消息的用户程序

 

RabbitMQ的消息模式的核心思想是生产者(Producer)从不将消息直接发送到一个队列(queue)中，实际上，很多时候生产者甚至不知道一个消息是否要分发到所有队列.

换言之，生产者(producer)只能够发送消息到一个交换区Exchange.. 对exchange发送消息是一个非常容易的事情.  从生产者producer方接收消息，从另一边将消息push到队列中。exchange必须清楚知道接收到的消息要如何处理. 是要将消息发送到一个指定queue？ 是要将消息发送到多个queue？ 还是丢弃？ 这个规则需要通过 exchange type 来定义

 

 

 

这里有几种exchange类型可用： direct  ,  topic ,  headers  和 fanout  。 我们将要对最后一种进行讲解  ---  fanout  。 我们创建一个 这种类型的exchange 并命名为logs：

1. channel.exchange_declare(exchange='logs',
2. type='fanout')

 

fanout exchange非常简单，你从这个名字中就能猜出来，它将从Producer方收到的消息广播给所有他知道的receiver方。而这正是我们的logger记录所需要的消息。

 

关于Exchange的几种模式：http://blog.csdn.net/songfreeman/article/details/50953288

 

exchanges列表

使用rabbitmqclt管理工具显示服务器上的exchanges列表

1. $ sudo rabbitmqctl list_exchanges
2. Listing exchanges ...
3. logs      fanout
4. amq.direct      direct
5. amq.topic       topic
6. amq.fanout      fanout
7. amq.headers     headers
8. ...done.

在这个列表中有一些amq.*  exchange和默认的exchange，这些都是默认创建的，但是这些未必是你所需要的。

 

匿名的exchange

在前面部分我们知道空的exchange， 但仍然能够发送消息到队列中，只是因为我们使用的是我们定义的空字符串“”exchange（默认的exchange）

回忆一下我们之前怎么发布一个消息：

1. channel.basic_publish(exchange='',
2. routing_key='hello',
3. body=message)

这个exchange参数就是这个exchange的名字. 空字符串标识默认的或者匿名的exchange：如果存在routing_key, 消息路由到routing_key指定的队列中。

 

现在我们可能够发布消息到我们自己命名的exchange:

1. channel.basic_publish(exchange='logs',
2. routing_key='',
3. body=message)

临时队列( Temporary queues )

你应该记得我们之前使用有一个特定名字的队列( hello、task_queue). 设置队列名对我们来说是至关重要的 --- 我们需要给消费方指定同样的队列名字。 要在生产者和消费者之间共享队列,给队列设置一个名字是非常重要的。

但是这不是我们日志应用的关键,我们希望获取到所有的日志消息，而不是他们的一个子集。我们只对当前活动的消息敢兴趣,对已经发过的旧的消息不关心。为了解决这个问题我们需要做两件事：

首先： 

无论什么时候我们连接到Rabbit我们需要一个空的、新的队列。为了实现这个我们可以创建个随机名的队列，或者，更好的 - 让服务端选择一个随机的队列名给我们，我们可以不给queue_declare方法设置queue参数来实现。

1. result = channel.queue_declare()

这样, result.method.queue 包含一个随机的队列名, 比如：看起来像 amq.gen-JzTY20BRgKO-HjmUJj0wLg.

其次：

一旦我们断开consumer连接，这个队列名将自动删除。这里有一个标识设置：

1. result = channel.queue_declare(exclusive=True)

绑定（Bindings）

我们已经创建了一个 fanout exchange 和一个队列queue, 现在我们需要告诉exchange发送消息到我们的queue中, 这个exchange与队列queue之间的关系我们成为 绑定（Bindings）

1. channel.queue_bind(exchange='logs',
2. queue=result.method.queue)

现在logs exchange 将要发送消息到我们的队列

 

1. 你可以在Server端通过rabbitmqctl list_bindings命令查看绑定信息

汇总(Putting it all together）

生产者(Producer)程序发出log消息，和前面介绍的章节没什么太大的区别。 主要的改变是我们想要发送消息到我们指定的logs exchange，而不是之前的那种匿名的exchange。 我们之前使用匿名exchange发送消息时Producer需要提供一个 routing_key，但当我们指定exchange为fanout exchange时，这个值(routing_key)将忽略。下面是 emit_log.py 脚本：

1. import pika
2. import sys
3. connection = pika.BlockingConnection(pika.ConnectionParameters(
4. host='localhost'))
5. channel = connection.channel()
6. channel.exchange_declare(exchange='logs',
7. type='fanout')
8. message = ' '.join(sys.argv[1:]) or "info: Hello World!"
9. channel.basic_publish(exchange='logs',
10. routing_key='',
11. body=message)
12. print(" [x] Sent %r" % message)
13. connection.close()

 

如你所见, 当建立连接之后我们定义了一个exchange名logs, 由于发布一个消息到一个不存在的exchange是禁止的，所以这一步是必须有的。

发送消息时，如果还没有队列绑定到这个exchange上的话，消息将会丢失。 但这个对我们来说是OK的；如果还没有消费者（consumer) 监听上我们可以安全的放弃这条消息。

 

receive_logs.py 脚本 :

1. import pika
2. connection = pika.BlockingConnection(pika.ConnectionParameters(
3. host='localhost'))
4. channel = connection.channel()
5. channel.exchange_declare(exchange='logs',
6. type='fanout')
7. result = channel.queue_declare(exclusive=True)  # 队列断开后自动删除临时队列
8. queue_name = result.method.queue   #  队列名采用服务端分配的临时队列
9. channel.queue_bind(exchange='logs',
10. queue=queue_name)
11. print(' [*] Waiting for logs. To exit press CTRL+C')
12. def callback(ch, method, properties, body):
13. print(" [x] %r" % body)
14. channel.basic_consume(callback,
15. queue=queue_name,
16. no_ack=True)
17. channel.start_consuming()

我们已经完成了，如果你想保存日志到一个文件，只需要打开终端执行：

1. $ python receive_logs.py > logs_from_rabbit.log

如果你想在屏幕上查看输出的日志,新开一个终端并运行：

1. $ python receive_logs.py

当然，发出日志信息：

1. $ python emit_log.py

使用 rabbitmqlctl list_bindings 你能验证代码确实创建了你想要的binding和队列。运行两个 receive_logs.py 程序你可以看到：

1. $ sudo rabbitmqctl list_bindings
2. Listing bindings ...
3. logs    exchange        amq.gen-JzTY20BRgKO-HjmUJj0wLg  queue           []
4. logs    exchange        amq.gen-vso0PVvyiRIL2WoV3i48Yg  queue           []
5. ...done.

这个结果的解释非常直白： 从 logs  exchange 出来的数据发送服务端自动分配的到两个队列名中，这也是我们预期的。

三、python系列之 RabbitMQ - RPC

远程过程调用（Remote procedure call (RPC))

在第二课我们学习了怎样使用 工作队列（work queues) 来在多个workers之间分发需要消时的 任务

但是如果我们需要在远程的服务器上调用一个函数并获取返回结果 我们需要怎么做呢？well这是一个不一样的故事。 这中模式通常被称为远程过程调用或RPC

在这一刻我们将要使用RabbitMQ来建立一个RPC系统：一个客户端和一个可扩展的RPC服务。由于我们没有任何耗时的任务值得分配，我们将要创建一个仿RPC服务并返回斐波纳契数值

客户端接口（Client interface）

为了阐明RPC服务怎么使用我们创建一个简单的客户端类，将用一个名为Call的方法发送一个RPC请求并阻塞直到获取结果：

1. fibonacci_rpc = FibonacciRpcClient()
2. result = fibonacci_rpc.call(4)
3. print("fib(4) is %r" % result)

回调队列（callback queue）

一般通过RabbitMQ执行RPC是很容易的。 一个客户端发送一个请求消息然后服务端返回一个消息作为应答。 为了接收返回消息客户端需要发送一个“callback" 队列请求地址，让我们试试：

1. result = channel.queue_declare(exclusive=True)
2. callback_queue = result.method.queue
3. channel.basic_publish(exchange='',
4. routing_key='rpc_queue',
5. properties=pika.BasicProperties(
6. reply_to = callback_queue,
7. ),
8. body=request)

消息属性

AMQP协议在一个消息中预先定义了一个包含14个属性的集合。大部分属性很少用到，以下几种除外：

> delivery_mode: 标记一个消息为持久的（值为2）或者 瞬时的（其它值）， 你需要记住这个属性（在第二课时用到过）

> content_type : 用来描述 MIME 类型的编码 ,比如我们经常使用的 JSON 编码，设置这个属性就非常好实现： application/json

> reply_to： 经常用来命名一个 callback 队列

> correlation_id ： 用来关联RPC的请求与应答

关联ID （Correlation ID）

前面提到的方法我们建议为每个RPC请求创建一个callback队列。  那是相当低效的，但是幸好有一个更好的方法 -- 我们未每个客户端创建一个单独的callback队列。

但这带来了一个新的问题， 当在那个队列中接收了一个返回，我们并不清楚是这个结果时属于那个请求的，这样当correlation_id属性使用后，我们为每个请求设置一个唯一值。然后当我们从callback队列中接收到一个消息后，我们查看一下这个属性，基于这个我们就能将请求和返回进行匹配。如果我们看到一个未知的correlation_id值，我们可以安全的丢弃这个消息 -- 不属于我们的请求

 

你可能会问，为什么我们要在callback队列中忽略未知的消息，而不是通过这个错误执行失败？ 这是由于服务端的竞争条件的可能性（？？），虽然可能性不大,但在为请求发送ack消息之前,当发送给我们结果后RPC服务还是有死掉的可能。如果发生这样的情况，让重启RPC服务之后将会重新处理请求。 这就是为什么客户端必须妥善的处理重复响应。

 

概要(Summary)

我们的RPC将会这样执行：

>  当客户端启动后，它创建一个匿名的唯一的回调队列

> 对一个RPC请求, 客户端发送一个消息包含两个属性： reply_to （用来设置回调队列）和 correlation_id（用来为每个请求设置一个唯一标识）

> 请求发送到 rpc_queue队列

> RPC worker( 服务端) 在那个队列中等待请求，当一个请求出现后，服务端就执行一个job并将结果消息发送给客户端，使用reply_to字段中的队列

> 客户端在callback 队列中等待数据, 当一个消息出现后，检查这个correlation_id属性,如果和请求中的值匹配将返回给应用

 

整合

rpc_server.py代码

 

1. #!/usr/bin/env python
2. import pika
3. connection = pika.BlockingConnection(pika.ConnectionParameters(
4. host='localhost'))
5. channel = connection.channel()
6. channel.queue_declare(queue='rpc_queue')
7. def fib(n):
8. if n == 0:
9. return 0
10. elif n == 1:
11. return 1
12. else:
13. return fib(n-1) + fib(n-2)
14. def on_request(ch, method, props, body):
15. n = int(body)
16. print(" [.] fib(%s)" % n)
17. response = fib(n)
18. ch.basic_publish(exchange='',
19. routing_key=props.reply_to,
20. properties=pika.BasicProperties(correlation_id = \
21. props.correlation_id),
22. body=str(response))
23. ch.basic_ack(delivery_tag = method.delivery_tag)
24. channel.basic_qos(prefetch_count=1)
25. channel.basic_consume(on_request, queue='rpc_queue')
26. print(" [x] Awaiting RPC requests")
27. channel.start_consuming()

 

服务端代码详单简单：

> (4) 和往常一样我们建立一个连接并定义一个队列

> (11) 我们定义了  斐波纳契 函数，假定输入的都是合法正数

> (19) 我们定义了一个回调的 basic_consume, RPC服务的核心。 当收到请求后执行这个函数并返回结果

> (32) 我们可能会执行多个服务端，为了在多个服务端上均匀的分布负荷，我们需要这是 prefetch_count。

 

rpc_client.py 代码：

 

1. #!/usr/bin/env python
2. import pika
3. import uuid
4. class FibonacciRpcClient(object):
5. def __init__(self):
6. self.connection = pika.BlockingConnection(pika.ConnectionParameters(
7. host='localhost'))
8. self.channel = self.connection.channel()
9. result = self.channel.queue_declare(exclusive=True)
10. self.callback_queue = result.method.queue
11. self.channel.basic_consume(self.on_response, no_ack=True,
12. queue=self.callback_queue)
13. def on_response(self, ch, method, props, body):
14. if self.corr_id == props.correlation_id:
15. self.response = body
16. def call(self, n):
17. self.response = None
18. self.corr_id = str(uuid.uuid4())
19. self.channel.basic_publish(exchange='',
20. routing_key='rpc_queue',
21. properties=pika.BasicProperties(
22. reply_to = self.callback_queue,
23. correlation_id = self.corr_id,
24. ),
25. body=str(n))
26. while self.response is None:
27. self.connection.process_data_events()
28. return int(self.response)
29. fibonacci_rpc = FibonacciRpcClient()
30. print(" [x] Requesting fib(30)")
31. response = fibonacci_rpc.call(30)
32. print(" [.] Got %r" % response)

 

客户端代码稍微复杂些：

> (7) 我们建立一个连接，通道并定义一个专门的’callback‘队列用来接收回复

> (16) 我们订阅了“callback”队列，因此我们能够接收 RPC 的返回结果

> (18) ’on_response'  在每个返回中执行的回调是一个简单的job， 对每个返回消息将检查是否correlation_id使我们需要查找的那个ID，如果是，将保存结果到 self.response 并终端consuming循环

> (23) 下一步，我们定义我们的main方法 - 执行实际的RPC请求

> (24) 在这方法中，首先我们生产一个唯一的 correlatin_id 号并保存 -- 'on_response"回调函数将用着号码来匹配发送和接收的消息值

> (25) 下一步，发布请求信息，使用两个属性： reply_to 和 correlation_id

> (32) 这一步我们可以坐等结果的返回

>(33) 最后我们返回结果给用户

 

我们的RPC服务现在已经就绪,可以开启服务：

1. $ python rpc_server.py
2. [x] Awaiting RPC requests

请求一个斐波那契数，运行客户端

1. $ python rpc_client.py
2. [x] Requesting fib(30)

四、redis

1.redis操作

设置值：set name 'wt'   再次执行set name 'qq'  会将name值设置为qq

取值：get name

2.在python中操作如下：

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

1 2 3 4 5 6

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

setnx(name, value)

1	设置值，只有name不存在时，执行设置操作（添加）

setex(name, value, time)

1 2 3

# 设置值 # 参数：     # time，过期时间（数字秒 或 timedelta对象）

psetex(name, time_ms, value)

1 2 3

# 设置值 # 参数：     # time_ms，过期时间（数字毫秒 或 timedelta对象）

mset(*args, **kwargs)

1 2 3 4 5

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

get(name)

1

获取值

mget(keys, *args)

1 2 3 4 5

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

getset(name, value)

1	设置新值并获取原来的值

getrange(key, start, end)

1 2 3 4 5 6

# 获取子序列（根据字节获取，非字符） # 参数：     # name，Redis 的 name     # start，起始位置（字节）     # end，结束位置（字节） # 如： "武沛齐" ，0-3表示 "武"

setrange(name, offset, value)

1 2 3 4

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

setbit(name, offset, value)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

# 对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         -------------------------- ----------------------------- -----------------------------                     武                         沛                           齐

getbit(name, offset)

1	# 获取name对应的值的二进制表示中的某位的值 （0或1）

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

1 2 3 4 5

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

bitop(operation, dest, *keys)

1 2 3 4 5 6 7 8 9 10

# 获取多个值，并将值做位运算，将最后的结果保存至新的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)

1	# 返回name对应值的字节长度（一个汉字3个字节）

incr(self, name, amount=1)

1 2 3 4 5 6 7

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。   # 参数：     # name,Redis的name     # amount,自增数（必须是整数）   # 注：同incrby

incrbyfloat(self, name, amount=1.0)

1 2 3 4 5

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。   # 参数：     # name,Redis的name     # amount,自增数（浮点型）

decr(self, name, amount=1)

1 2 3 4 5

# 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。   # 参数：     # name,Redis的name     # amount,自减数（整数）

append(key, value)

1 2 3 4 5

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

　　

Hash操作，redis中Hash在内存中的存储格式如下图：

hset(name, key, value)

1 2 3 4 5 6 7 8 9

# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）   # 参数：     # name，redis的name     # key，name对应的hash中的key     # value，name对应的hash中的value   # 注：     # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）

hmset(name, mapping)

1 2 3 4 5 6 7 8

# 在name对应的hash中批量设置键值对   # 参数：     # name，redis的name     # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}   # 如：     # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hget(name,key)

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

hmget(name, keys, *args)

1 2 3 4 5 6 7 8 9 10 11

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

1	获取name对应hash的所有键值

hlen(name)

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

hkeys(name)

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

hvals(name)

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

hexists(name, key)

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

hdel(name,*keys)

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

hincrby(name, key, amount=1)

1 2 3 4 5

# 自增name对应的hash中的指定key的值，不存在则创建key=amount # 参数：     # name，redis中的name     # key， hash对应的key     # amount，自增数（整数）

hincrbyfloat(name, key, amount=1.0)

1 2 3 4 5 6 7 8

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

1 2 3 4 5 6 7 8 9 10 11 12 13

# 增量式迭代获取，对于数据大的数据非常有用，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)

1 2 3 4 5 6 7 8 9

# 利用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)

1 2 3 4 5 6 7 8

# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边   # 如：     # r.lpush('oo', 11,22,33)     # 保存顺序为: 33,22,11   # 扩展：     # rpush(name, values) 表示从右向左操作

lpushx(name,value)

1 2 3 4

# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边   # 更多：     # rpushx(name, value) 表示从右向左操作

llen(name)

1	# name对应的list元素的个数

linsert(name, where, refvalue, value))

1 2 3 4 5 6 7

# 在name对应的列表的某一个值前或后插入一个新值   # 参数：     # name，redis的name     # where，BEFORE或AFTER     # refvalue，标杆值，即：在它前后插入数据     # value，要插入的数据

r.lset(name, index, value)

1 2 3 4 5 6

# 对name对应的list中的某一个索引位置重新赋值   # 参数：     # name，redis的name     # index，list的索引位置     # value，要设置的值

r.lrem(name, value, num)

1 2 3 4 5 6 7 8

# 在name对应的list中删除指定的值   # 参数：     # name，redis的name     # value，要删除的值     # num，  num=0，删除列表中所有的指定值；            # num=2,从前到后，删除2个；            # num=-2,从后向前，删除2个

lpop(name)

1 2 3 4

# 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素   # 更多：     # rpop(name) 表示从右向左操作

lindex(name, index)

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

lrange(name, start, end)

1 2 3 4 5

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

ltrim(name, start, end)

1 2 3 4 5

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

rpoplpush(src, dst)

1 2 3 4

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

blpop(keys, timeout)

1 2 3 4 5 6 7 8

# 将多个列表排列，按照从左到右去pop对应列表的元素   # 参数：     # keys，redis的name的集合     # timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞   # 更多：     # r.brpop(keys, timeout)，从右向左获取数据

brpoplpush(src, dst, timeout=0)

1 2 3 4 5 6

# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧   # 参数：     # src，取出并要移除元素的列表对应的name     # dst，要插入元素的列表对应的name     # timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞

自定义增量迭代

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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

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

scard(name)

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

sdiff(keys, *args)

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

sdiffstore(dest, keys, *args)

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

sinter(keys, *args)

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

sinterstore(dest, keys, *args)

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

sismember(name, value)

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

smembers(name)

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

smove(src, dst, value)

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

spop(name)

1	# 从集合的右侧（尾部）移除一个成员，并将其返回

srandmember(name, numbers)

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

srem(name, values)

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

sunion(keys, *args)

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

sunionstore(dest,keys, *args)

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

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

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

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

zadd(name, *args, **kwargs)

1 2 3 4 5

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

zcard(name)

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

zcount(name, min, max)

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

zincrby(name, value, amount)

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# 按照索引范围获取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)

1 2 3 4

# 获取某个值在 name对应的有序集合中的排行（从 0 开始）   # 更多：     # zrevrank(name, value)，从大到小排序

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （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)

1 2 3

# 删除name对应的有序集合中值是values的成员   # 如：zrem('zz', ['s1', 's2'])

zremrangebyrank(name, min, max)

1	# 根据排行范围删除

zremrangebyscore(name, min, max)

1	# 根据分数范围删除

zremrangebylex(name, min, max)

1

# 根据值返回删除

zscore(name, value)

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

zinterstore(dest, keys, aggregate=None)

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

zunionstore(dest, keys, aggregate=None)

1 2	# 获取两个有序集合的并集，如果遇到相同值不同分数，则按照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)

1	# 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作

　　

其他常用操作

delete(*names)

1	# 根据删除redis中的任意数据类型

exists(name)

1	# 检测redis的name是否存在

keys(pattern='*')

1 2 3 4 5 6 7

# 根据模型获取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)

1	# 为某个redis的某个name设置超时时间

rename(src, dst)

1	# 对redis的name重命名为

move(name, db))

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

randomkey()

1	# 随机获取一个redis的name（不删除）

type(name)

1	# 获取name对应值的类型

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

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

　

4、管道

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

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#!/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)#True为打开同时请求多个指令的功能   pipe.set('name', 'alex') pipe.set('role', 'sb')   pipe.execute()