python自动化编程-第十一天 rabbitmq redis
python自动化编程-第十一天 rabbitmq redis
rabbitmq
rabbitmq是什么？
erlang 语言开发 需要安装erlang
RabbitMQ 是一个消息代理: 它接受和转发消息。你可以把它想成邮局: 当你把你的邮件放在一个邮政信箱时, 你相信邮递员最终将邮件传递给你的收件人。在这个比喻中, RabbitMQ 是一个邮政信箱, 一个邮局和一个邮递员。
RabbitMQ 和邮局的主要区别在于它不处理纸张, 而是接受、存储和转发数据的二进制消息.
RabbitMQ 和消息传递通常使用一些术语。
生产消息只是为了发送消息。发送消息的程序是生产者。
队列驻留在RabbitMQ中的邮箱的名称。虽然消息流经 RabbitMQ 和应用程序, 但它们只能存储在队列中。队列只受主机的内存 & 磁盘限制的约束, 它实质上是一个大的消息缓冲区。许多生产者可以发送到一个队列的消息, 许多消费者可以尝试从一个队列接收数据。这就是我们如何表示队列的方式。
消费与接受有着相似的含义。消费者是一个程序，主要是等待接收信息:
生产者、消费者和rabbitmq不一定要在一台主机上；
为什么要用rabbitmq（消息队列）？
1、为了能够2个程序能够交互数据
通过socket，程序臃肿
通过硬盘（文件），效率低
2、python有自己的 消息队列，为什么用rabbitmq？
python的线程队列，python的进程队列
但是python的进程队列只能父进程与子进程进行交互；或者同属于 同一父进程下的多个子进程进行交互
所以使用一个第三方的队列程序让python进程之间能够交互数据
安装
安装rabbitmq
windows上安装
https://www.rabbitmq.com/install-windows.html
mac上安装
https://www.rabbitmq.com/install-standalone-mac.html
linux上安装
centos：
https://www.rabbitmq.com/install-rpm.html
ubuntu：
https://www.rabbitmq.com/install-debian.html
python rabbitMQ module
pika, a pure-Python AMQP 0-9-1 client (source code, API reference)
Celery, a distributed task queue for Django and pure Python
Haigha, an asynchronous AMQP 0-9-1 client based on libevent (the source code and docs are on github)
通常使用pika模块即可；
pip install pika
or
easy_install pika
or
源码
https://pypi.python.org/pypi/pika
https://www.rabbitmq.com/getstarted.html
rabbitmq初始化
配置用户名与密码
# 添加用户名和密码
sudo rabbitmqctl add_user alex alex3714
# 配置权限，允许从外面访问
sudo rabbitmqctl set_permissions -p / alex ".*" ".*" ".*"
set_permissions [-p vhost] {user} {conf} {write} {read}
vhost
授予用户访问权限的虚拟主机的名称，默认为/。
user
授予对指定虚拟主机的访问权限的用户名。
conf
一个正则表达式匹配资源名，用户被授予配置权限。
write
一个匹配资源名称的正则表达式，授予用户写权限。
read
一个正则表达式，匹配授予用户读权限的资源名称。
简单的发布和订阅
发布者 P
import pika
credentials = pika.PlainCredentials('czlan', 'czlan')
connection = pika.BlockingConnection(
# pika.ConnectionParameters('localhost')
pika.ConnectionParameters('192.168.255.128',5672,'/',credentials)
)
channel = connection.channel() # 声明一个管道
# 声明 queue 在管道
channel.queue_declare(queue='hello')
channel.basic_publish(
exchange='',
routing_key='hello', # queue 名字
body='hello word!', # 内容
)
print(" [x] Sent 'Hello World!'")
connection.close() # 不用关闭管道，直接关闭队列
订阅者 C
import pika
import time
credentials = pika.PlainCredentials('czlan', 'czlan')
connection = pika.BlockingConnection(
pika.ConnectionParameters('192.168.255.128',5672,'/',credentials)
# pika.ConnectionParameters('localhost')
)
channel = connection.channel() # 声明一个管道
# 声明 queue 在管道
# You may ask why we declare the queue again
# ‒ we have already declared it in our previous code.
# We could avoid that if we were sure that the queue already exists.
# For example if send.py program was run before.
# But we're not yet sure which program to run first.
# In such cases it's a good practice to repeat declaring the queue in both programs.
channel.queue_declare(queue='hello')
def callback(ch, method, properties, body): # 回调 ， 类似事件触发
print(ch,method,properties)
time.sleep(30)
print(" [x] Received %r" % body)
ch.basic_ack(delivery_tag=method.delivery_tag)
# ch 是channel的内存对象地址，我们声明的
# method 是发送给哪个队列的标记
channel.basic_qos(prefetch_count=1) # 当消费者处理完这个消息 ，在给当前消费者发送第二条； 处理消息慢的 生产者就会少发；
channel.basic_consume(
callback, # 如果收到消息，就调用CALLBACK函数来处理消息
queue='hello', # 收消息的队列
no_ack=True # no ackownledgement 不关心信息是否处理完成，一般都不加，让rabbitmq自己去确认消息是否处理完成
)
channel.start_consuming()
注意：当rabbitmq安装在本地，并且在本地调用rabbitmq时，则不需要用户名和密码，直接输入pika.ConnectionParameters('localhost')即可
在发送消息之前, 我们需要确保收件人队列存在。如果我们向不存在的位置发送消息, RabbitMQ 将只丢弃该消息，因此在两个程序中重复声明队列是一种很好的做法
查看rabbitmq-server有哪些队列以及其中有多少条消息
sudo rabbitmqctl list_queues
工作队列
默认情况下, RabbitMQ 将按顺序将每条消息发送到下一个消费者。平均每位消费者将得到相同数量的邮件。这种分发消息的方式称为 "循环"；类似于负载均衡模式。
消息确认
在消费者端不加no_ack=True参数，此参数表示不关心消息是否处理完成；
rabbitmq的处理流程：
- 生产者生产一个数据，消费者接受以后，如果callback函数执行完成，则表示这个消息处理完成，那么就要手动发送一个确认消息给rabbitmq，告诉生产者这个消息处理完成，生产者就会把这个消息给删除了，
- 如果生产者没有收到这个消息处理完成的确认，生产者不会删除这个消息，而在此期间如果检测到消费者断开（连接rabbitmq使用socket连接的，因此通过socket来检测消费者是否断开），则会继续发送消息给其他消费者；
默认情况下,手动消息确认处于打开状态。在前面的示例中, 我们通过no_ack = true显式关闭它们。
def callback(ch, method, properties, body):
print " [x] Received %r" % (body,)
time.sleep( body.count('.') )
print " [x] Done"
ch.basic_ack(delivery_tag = method.delivery_tag) # 手动确认
channel.basic_consume(callback,
queue='hello') # 删除 no_ack = true
消息队列持久化
当 RabbitMQ 退出或崩溃时, 它会忘记队列和消息, 除非您告诉它不要这样做。需要两件事情来确保邮件不会丢失: 我们需要将队列和消息标记为持久性。
队列持久化
channel.quue_declare(queue='hello',durable=True)
注意：已创建的队列，不能修改参数，RabbitMQ 不允许您重新定义具有不同参数的现有队列, 并会将错误返回到任何尝试执行此项的程序
消息持久化：
channel.basic_publish(exchange='',
routing_key="queue",# queue名字
body='hello word!', # 内容
properties=pika.BasicProperties(
delivery_mode = 2, # make message persistent，队列消息持久化
))
公平派遣
例如, 在两个工人的情况下, 当有些消息是很费时间的, 而有些消息是简单的, 那么一个消费者将不断忙碌, 另一个将做几乎没有任何工作。 RabbitMQ 对此一无所知, 并且仍然会将消息均匀地发送出去。
发生这种情况的原因是, 当消息进入队列时, RabbitMQ 只是调度了一条消息。它不查看使用者的未确认邮件数。它只是盲目地将每一个 n 次信息发送给 n 个消费者。
通过设置参数channel.basic_qos(prefetch_count=1)
告诉 RabbitMQ 不要一次给一个消费者一个以上的消息。或者, 换言之, 在处理并确认前一条消息之前, 不要向消费者发送新消息。相反, 它会将它分派给不太忙的下一个消费者。
示例
生产者 p
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='task_queue', durable=True) # durable 表示队列是持久的，但是queue的名称不能再rabbitmq中存在
message = ' '.join(sys.argv[1:]) or "Hello World!"
channel.basic_publish(exchange='',
routing_key='task_queue',
body=message,
properties=pika.BasicProperties(
delivery_mode = 2, # make message persistent 消息持久化
))
print(" [x] Sent %r" % message)
connection.close()
消费者 c
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') # 取消 no_ack参数
channel.start_consuming()
订阅与发送
exchange
生产者是发送消息的用户应用程序。
队列是存储消息的缓冲区。
使用者是接收消息的用户应用程序。
RabbitMQ 消息模型中的核心思想是生产者从不直接向队列发送任何消息。事实上, 通常生产者甚至不知道消息是否会被传递到任何队列中。
相反, 生产者只能向exchange发送消息。exchange是一件很简单的东西。一方面, 它接收来自生产者的消息, 另一侧则将其推送到队列中。exchange 必须确切知道如何处理接收到的消息。是否应追加到特定队列中？是否应追加到多个队列中？或者应该被丢弃。此规则由exchange 类型定义.
exchange的类型
direct:通过routingKey和exchange决定的那个唯一的queue可以接收消息
topic:所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息
headers:通过headers 来决定把消息发给哪些queue
fanout:将接收到的所有消息广播到它知道的所有队列中
广播，都是实时的，客户端启动之前，服务器发送的消息都会消失；类似收音机的模型，
声明exchange
channel.exchange_declare(exchange='logs',
exchange_type='fanout')
查看rabbitmq-server上的exchange：
sudo rabbitmqctl list_exchanges
列出rabbitmq-server的bind关系
rabbitmqctl list_bindings
临时队列
result = channel.queue_declare(exclusive=True)
# 不写queue名称，rabbitmq会自动生成一个，
# exclusive = true表示一旦关闭了消费者连接, 就删除该队列
queue_name = result.method.queue
# 随机生成的队列名称
绑定
channel.queue_bind(exchange='logs',
queue=queue_name)
fanout示例
生产者 p
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
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()
消费者 c
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs',
exchange_type='fanout')
result = channel.queue_declare(exclusive=True)
# 不写queue名称，rabbitmq会自动生成一个，
# exclusive = true表示一旦关闭了消费者连接, 就删除该队列
queue_name = result.method.queue
# 随机生成的队列名称
channel.queue_bind(exchange='logs',
queue=queue_name)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] %r" % body)
channel.basic_consume(callback,
queue=queue_name,
no_ack=True)
channel.start_consuming()
routing
fanout exchange, 这并没有给我们太多的灵活性-它只能够盲目的广播。
接下来将使用direct，direct exchange的路由算法很简单-一条消息转到其binding_key与消息的routing_key完全匹配的队列中。
在这个设置中, 我们可以看到直接交换X与两个绑定到它的队列。第一个队列绑定有绑定密钥橙色, 第二个则有两个绑定, 一个具有绑定密钥黑色, 另一条带有绿色.
在这样的设置中, 将路由密钥橙色发布到 exchange 的消息将被路由到队列Q1。带有黑色或绿色路由键的邮件将转到Q2。所有其他消息将被丢弃。
direct示例
生产者p
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) > 2 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()
消费者c
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]\n" % 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_logs_direct.py warning error > logs_from_rabbit.log
# 如果希望查看屏幕上的所有日志消息, 请打开一个新的终端并执行以下操作:
>>> python receive_logs_direct.py info warning error
# => [*] Waiting for logs. To exit press CTRL+C
# 例如, 要发出错误日志消息, 请键入:
>>> python emit_log_direct.py error "Run. Run. Or it will explode."
# => [x] Sent 'error':'Run. Run. Or it will explode.'
topic
发送到topic exchange的消息不能有任意的routing_key -它必须是由点分隔的单词列表
* 只能用一个词来代替。
# 可以替代零个或多个单词。
生产者
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) > 2 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]...\n" % 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_logs_topic.py "#"
# 接收设备中的所有日志 "kern":
>>> python receive_logs_topic.py "kern.*"
# 或者, 如果您只想听到 "critical" 日志:
>>> python receive_logs_topic.py "*.critical"
# 可以创建多个绑定:
>>> python receive_logs_topic.py "kern.*" "*.critical"
# 并使用路由键 "kern.critical" 类型发出日志:
>>> python emit_log_topic.py "kern.critical" "A critical kernel error"
远程过程调用 (RPC)
当客户端启动时, 它会创建一个匿名独占回调队列。
对于 RPC 请求, 客户端发送具有两个属性的消息: reply_to, 它被设置为回调队列和correlation_id, 它被设置为每个请求的唯一值。
请求被发送到rpc_queue队列。
RPC 消费者 (又名: 服务器) 正在等待该队列上的请求。当出现请求时, 它会使用reply_to字段中的队列, 并将返回的消息发送回客户端。
客户端等待回调队列上的数据。当出现消息时, 它会检查correlation_id属性。如果它与请求的值匹配, 它将返回对应用程序的响应。
server
import pika
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()
server端
1.首先建立连接并声明队列。
2.宣布斐波那契函数。它只假定有效的正整数输入。
3.声明对 RPC 服务器的核心basic_consume的回调。在收到请求时执行,并发送回响应。
4.为了在多个服务器上平均分配负载, 我们需要设置prefetch_count设置。
client
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)
clinet：
1.建立一个连接, 通道, 并声明一个独占 ' 回调 ' 队列的答复。
2.订阅 "回调" 队列, 以便我们可以接收 RPC 响应，在构造函数中定义。
3.每个响应执行的 "on_response" 回调操作, 对于每一个响应消息, 它检查如果correlation_id是我们要寻找的。它会将响应保存在自己的响应中, 并中断循环。
4.接下来, 定义了主调用方法-它做实际的 RPC 请求。
5.在这种方法中, 首先生成一个唯一的correlation_id数字并保存它-"on_response" 回调函数将使用此值捕获适当的响应。
6.接下来, 发布请求消息, 具有两个属性: reply_to和correlation_id.
7.等待, 结果返回。
8.最后, 将结果返回给用户。
redis 缓存
为什么要用redis？
让两个程序共享一个内存空间。
使用文件的方式效率低下，因此需要使用一个第三方的进程，并使用socket连接
缓存常用软件
mongodb 默认持久化
redis 可指定持久化
memcache 只能存在内存中，不能持久化
安装模块
pip3 install redis
文档：
https://redis-py.readthedocs.io/en/latest/#
redis server 安装
centos：
从epel源中安装
yum install redis
systemctl start redis
redis-cli # 进入命令行模式
桌面管理系统
要在Ubuntu 上安装 Redis桌面管理，可以从 http://redisdesktop.com/download 下载包并安装它。
Redis 桌面管理器会给你用户界面来管理 Redis 键和数据。
Redis API使用
redis-py 的API的使用可以分类为：
1、连接方式
2、连接池
3、操作
String 操作
Hash 操作
List 操作
Set 操作
Sort Set 操作
4、管道
5、发布订阅
连接方式
1、操作模式
redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。
import redis
r = redis.Redis(host='10.211.55.4', port=6379)
r.set('foo', 'Bar')
print r.get('foo')
2、连接池
redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。
import redis
pool = redis.ConnectionPool(host='10.211.3.5',port=6379)
r = redis.Redis(connection_pool=pool)
r.set('foo','bar')
print(r.get('foo'))
操作
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，结束位置（字节）
# 如： "武沛齐" ，0-3表示 "武"
setrange(name, offset, value)
# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
# 参数：
# offset，字符串的索引，字节（一个汉字三个字节）
# value，要设置的值
setbit(name, offset, value)
# 对name对应值的二进制表示的位进行操作
# 参数：
# name，redis的name
# offset，位的索引（将值变换成二进制后再进行索引）
# value，值只能是 1 或 0
# 注：如果在Redis中有一个对应： n1 = "foo"，
那么字符串foo的二进制表示为：01100110 01101111 01101111
所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
那么最终二进制则变成 01100111 01101111 01101111，即："goo"
# 扩展，转换二进制表示：
# 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
-------------------------- ----------------------------- -----------------------------
武 沛 齐
用途举例，用最省空间的方式，存储在线用户数及分别是哪些用户在线
统计在线人数
incl user_login 自增加
decl user_login 自减
统计哪个人在线，根据用户ID
setbit user_online 用户ID 1
bitcount user_online 统计1的个数就知道有多少人在线了，可以获取谁在线
getbit user_online 用户id
getbit(name, offset)
# 获取name对应的值的二进制表示中的某位的值 （0或1）
bitcount(key, start=None, end=None)
# 获取name对应的值的二进制表示中 1 的个数
# 参数：
# key，Redis的name
# start，位起始位置
# end，位结束位置
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, 要追加的字符串
hash操作
hash表现形式上有些像pyhton中的dict,可以存储一组关联性较强的数据 ， redis中Hash在内存中的存储格式如下图：
hset(name, key, value)
# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
# 参数：
# name，redis的name
# key，name对应的hash中的key
# value，name对应的hash中的value
# 注：
# hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
hmset(name, mapping)
# 在name对应的hash中批量设置键值对
# 参数：
# name，redis的name
# mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
# 如：
# r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
hget(name,key)
# 在name对应的hash中获取根据key获取value
hmget(name, keys, *args)
# 在name对应的hash中获取多个key的值
# 参数：
# name，reids对应的name
# keys，要获取key集合，如：['k1', 'k2', 'k3']
# *args，要获取的key，如：k1,k2,k3
# 如：
# r.mget('xx', ['k1', 'k2'])
# 或
# print r.hmget('xx', 'k1', 'k2')
hgetall(name)
获取name对应hash的所有键值
hlen(name)
# 获取name对应的hash中键值对的个数
hkeys(name)
# 获取name对应的hash中所有的key的值
hvals(name)
# 获取name对应的hash中所有的value的值
hexists(name, key)
# 检查name对应的hash是否存在当前传入的key
hdel(name,*keys)
# 将name对应的hash中指定key的键值对删除
hincrby(name, key, amount=1)
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
# name，redis中的name
# key， hash对应的key
# amount，自增数（整数）
hincrbyfloat(name, key, amount=1.0)
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
# name，redis中的name
# key， hash对应的key
# amount，自增数（浮点数）
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
hscan(name, cursor=0, match=None, count=None)
Start a full hash scan with:
HSCAN myhash 0
Start a hash scan with fields matching a pattern with:
HSCAN myhash 0 MATCH order_*
Start a hash scan with fields matching a pattern and forcing the scan command to do more scanning with:
HSCAN myhash 0 MATCH order_* COUNT 1000
# 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
# 参数：
# name，redis的name
# cursor，游标（基于游标分批取获取数据）
# match，匹配指定key，默认None 表示所有的key
# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
# 如：
# 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
# 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
# ...
# 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕
hscan_iter(name, match=None, count=None)
# 利用yield封装hscan创建生成器，实现分批去redis中获取数据
# 参数：
# match，匹配指定key，默认None 表示所有的key
# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
# 如：
# for item in r.hscan_iter('xx'):
# print item
list
List操作，redis中的List在在内存中按照一个name对应一个List来存储。如图：
lpush(name,values)
# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
# 如：
# r.lpush('oo', 11,22,33)
# 保存顺序为: 33,22,11
# 扩展：
# rpush(name, values) 表示从右向左操作
lpushx(name,value)
# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
# 更多：
# rpushx(name, value) 表示从右向左操作
llen(name)
# name对应的list元素的个数
linsert(name, where, refvalue, value))
# 在name对应的列表的某一个值前或后插入一个新值
# 参数：
# name，redis的name
# where，BEFORE或AFTER
# refvalue，标杆值，即：在它前后插入数据
# value，要插入的数据
r.lset(name, index, value)
# 对name对应的list中的某一个索引位置重新赋值
# 参数：
# name，redis的name
# index，list的索引位置
# value，要设置的值
r.lrem(name, value, num)
# 在name对应的list中删除指定的值
# 参数：
# name，redis的name
# value，要删除的值
# num， num=0，删除列表中所有的指定值；
# num=2,从前到后，删除2个；
# num=-2,从后向前，删除2个
lpop(name)
# 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
# 更多：
# rpop(name) 表示从右向左操作
lindex(name, index)
在name对应的列表中根据索引获取列表元素
lrange(name, start, end)
# 在name对应的列表分片获取数据
# 参数：
# name，redis的name
# start，索引的起始位置
# end，索引结束位置
ltrim(name, start, end)
# 在name对应的列表中移除没有在start-end索引之间的值
# 参数：
# name，redis的name
# start，索引的起始位置
# end，索引结束位置
rpoplpush(src, dst)
# 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
# 参数：
# src，要取数据的列表的name
# dst，要添加数据的列表的name
blpop(keys, timeout)
# 将多个列表排列，按照从左到右去pop对应列表的元素
# 参数：
# keys，redis的name的集合
# timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
# 更多：
# r.brpop(keys, timeout)，从右向左获取数据
brpoplpush(src, dst, timeout=0)
# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
# 参数：
# src，取出并要移除元素的列表对应的name
# dst，要插入元素的列表对应的name
# timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
set集合操作
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, keynums，keys, aggregate=None)
# 获取两个有序集合的交集，遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为: SUM MIN MAX，默认为sum
keynums：表示多少个集合，
zunionstore(dest, keynums，keys, aggregate=None)
# 获取两个有序集合的并集，遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为: SUM MIN MAX
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)
# 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作
其他常用操作
delete(*names)
# 根据删除redis中的任意数据类型
exists(name)
# 检测redis的name是否存在
keys(pattern='*')
# 根据模型获取redis的name
# 更多：
# KEYS * 匹配数据库中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
expire(name ,time)
# 为某个redis的某个name设置超时时间
rename(src, dst)
# 对redis的name重命名为
move(name, db))
# 将redis的某个值移动到指定的db下
randomkey()
# 随机获取一个redis的name（不删除）
type(name)
# 获取name对应值的类型
scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)
# 同字符串操作，用于增量迭代获取key
管道
redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import redis
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
r = redis.Redis(connection_pool=pool)
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
pipe.set('name', 'alex')
pipe.set('role', 'sb')
pipe.execute()
发布和订阅
import redis
class RedisHelper:
def __init__(self):
self.__conn = redis.Redis(host='10.211.55.4')
self.chan_sub = 'fm104.5'
self.chan_pub = 'fm104.5'
def public(self, msg):
self.__conn.publish(self.chan_pub, msg)
return True
def subscribe(self):
pub = self.__conn.pubsub()
pub.subscribe(self.chan_sub)
pub.parse_response()
return pub
订阅者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from monitor.RedisHelper import RedisHelper
obj = RedisHelper()
redis_sub = obj.subscribe()
while True:
msg= redis_sub.parse_response()
print msg
发布者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from monitor.RedisHelper import RedisHelper
obj = RedisHelper()
obj.public('hello')
twisted 异步网络框架
http://www.cnblogs.com/alex3714/articles/5248247.html
浙公网安备 33010602011771号