这次文章包含两个内容：

1.RabbitMQ使用

2.Redis基础操作

代码部分为练习笔记和作业

概念部分转自Alex老师

RabbitMQ

安装 http://www.rabbitmq.com/install-standalone-mac.html

安装python rabbitMQ module

基础的实现案例

队列持久化、消息持久化、消息公平分发，实现起来都非常容易

代码里便都有备注

Consumer

  1. # _*_coding:utf-8_*_
  2. import time
  3. import pika
  4.  
  5. connection = pika.BlockingConnection(pika.ConnectionParameters(
  6.     'localhost'))
  7. channel = connection.channel()
  8. # You may ask why we declare the queue again ‒ we have already declared it in our previous code.
  9. # We could avoid that if we were sure that the queue already exists. For example if send.py program
  10. # was run before. But we're not yet sure which program to run first. In such cases it's a good
  11. # practice to repeat declaring the queue in both programs.
  12. channel.queue_declare(queue='hello', durable=True) #durable 队列持久化
  13.  
  14. def callback(ch, method, properties, body):
  15.     print(" [x] Received %r" % body)
  16.     time.sleep(20)
  17.     print(" [x] Done")
  18.     print("method.delivery_tag",method.delivery_tag)
  19.     ch.basic_ack(delivery_tag=method.delivery_tag) #将处理完成的结果反馈给queue
  20.  
  21. channel.basic_qos(prefetch_count=1) #消息公平分发
  22. channel.basic_consume(callback,
  23.                       queue='hello',
  24.                       no_ack=True) #让队列等待结果 #Tell the broker to expect a response
  25. print(' [*] Waiting for messages. To exit press CTRL+C')
  26. channel.start_consuming()

Producer

  1. # !/usr/bin/env python
  2. import pika
  3.  
  4. connection = pika.BlockingConnection(pika.ConnectionParameters(
  5.     'localhost'))
  6. channel = connection.channel()
  7. # 声明queue
  8. channel.queue_declare(queue='hello', durable=True) #durable 队列持久化
  9.  
  10. # n RabbitMQ a message can never be sent directly to the queue, it always needs to go through an exchange.
  11. channel.basic_publish(exchange='',
  12.                       routing_key='hello',
  13.                       body='Hello World!',
  14.                       properties=pika.BasicProperties(delivery_mode=2,)#消息持久化  # make message persistent
  15.                       )
  16. print(" [x] Sent 'Hello World!'")
  17. connection.close()

广播模式

Publish-fanout模式

  1. #Authon Ivor
  2. import pika
  3. import sys
  4.  
  5. connection = pika.BlockingConnection(pika.ConnectionParameters(
  6.     host='localhost'))
  7. channel = connection.channel()
  8.  
  9. channel.exchange_declare(exchange='logs',
  10.                          type='fanout')  #不再定义queue，只声明exchange
  11.  
  12. message = ' '.join(sys.argv[1:]) or "info: Hello World!"
  13. channel.basic_publish(exchange='logs',
  14.                       routing_key='',
  15.                       body=message)
  16. print(" [x] Sent %r" % message)
  17. connection.close()

Subscribe-fanout模式

  1. #Authon Ivor
  2. # _*_coding:utf-8_*_
  3. import pika
  4.  
  5. connection = pika.BlockingConnection(pika.ConnectionParameters(
  6.     host='localhost'))
  7. channel = connection.channel()
  8.  
  9. channel.exchange_declare(exchange='logs',
  10.                          type='fanout')
  11.  
  12. result = channel.queue_declare(exclusive=True)  # 不指定queue名字,rabbit会随机分配一个名字,exclusive=True会在使用此queue的消费者断开后,自动将queue删除
  13. queue_name = result.method.queue
  14.  
  15. channel.queue_bind(exchange='logs',
  16.                    queue=queue_name)
  17.  
  18. print(' [*] Waiting for logs. To exit press CTRL+C')
  19.  
  20. def callback(ch, method, properties, body):
  21.     print(" [x] %r" % body)
  22.  
  23. channel.basic_consume(callback,
  24.                       queue=queue_name,
  25.                       no_ack=True)
  26. channel.start_consuming()

Publish-direct模式

  1. #Authon Ivor
  2. import pika
  3. import sys
  4. connection = pika.BlockingConnection(pika.ConnectionParameters(
  5.     host='localhost'))
  6. channel = connection.channel()
  7. channel.exchange_declare(exchange='direct_logs',
  8.                          type='direct')
  9. severity = sys.argv[1] if len(sys.argv) > 1 else 'info'
  10. message = ' '.join(sys.argv[2:]) or 'Hello World!'
  11. channel.basic_publish(exchange='direct_logs',
  12.                       routing_key=severity,
  13.                       body=message)
  14. print(" [x] Sent %r:%r" % (severity, message))
  15. connection.close()

Subscribe-direct模式

  1. #Authon Ivor
  2. import pika
  3. import sys
  4. connection = pika.BlockingConnection(pika.ConnectionParameters(
  5.     host='localhost'))
  6. channel = connection.channel()
  7. channel.exchange_declare(exchange='direct_logs',
  8.                          type='direct')
  9. result = channel.queue_declare(exclusive=True)
  10. queue_name = result.method.queue
  11. severities = sys.argv[1:]
  12.  
  13. if not severities:
  14.     sys.stderr.write("Usage: %s [info] [warning] [error]\n" % sys.argv[0])
  15.     sys.exit(1)
  16.  
  17. for severity in severities:
  18.     channel.queue_bind(exchange='direct_logs',
  19.                        queue=queue_name,
  20.                        routing_key=severity)
  21.  
  22. print(' [*] Waiting for logs. To exit press CTRL+C')
  23.  
  24. def callback(ch, method, properties, body):
  25.     print(" [x] %r:%r" % (method.routing_key, body))
  26.  
  27. channel.basic_consume(callback,
  28.                       queue=queue_name,
  29.                       no_ack=True)
  30. channel.start_consuming()

RPC SSH命令执行 实现Demo

Client端

  1. #Author:Ivor
  2. import pika
  3. import uuid
  4. import time,random,json
  5.  
  6. class Cmd_RPC_Client(object):
  7.     def __init__(self):
  8.         self.task_dic = {}
  9.         self.corr_id = str(uuid.uuid4())
  10.         self.connection = pika.BlockingConnection(pika.ConnectionParameters(
  11.             host='localhost'))
  12.         self.channel = self.connection.channel()
  13.         result = self.channel.queue_declare(exclusive=True)
  14.         self.callback_queue = result.method.queue
  15.         self.channel.basic_consume(self.on_response,
  16.                                    no_ack=True,
  17.                                    queue=self.callback_queue)
  18.  
  19.     def on_response(self, ch, method, props, body):
  20.         if self.corr_id == props.correlation_id:
  21.             # print(self.response)
  22.             self.response = json.loads(body.decode())
  23.             task_id = self.response["task_id"]
  24.             res = self.response
  25.             self.task_dic[task_id] = res
  26.  
  27.     def run(self,cmd_list):
  28.         if cmd_list[0] == "run":
  29.             if cmd_list[2].startswith("-"):
  30.                 cmd = cmd_list[1] + " " + cmd_list[2]
  31.                 hosts = cmd_list[4:]
  32.             else:
  33.                 cmd = cmd_list[1]
  34.                 hosts = cmd_list[3:]
  35.             print(cmd, hosts)
  36.             task_id = str(time.time())[-4:]
  37.             msg = {
  38.                 "task_id":task_id,
  39.                 "cmd":cmd,
  40.                 "hosts":hosts
  41.             }
  42.             msg = json.dumps(msg).encode()
  43.             self.call(msg)
  44.             self.task_dic[task_id] = None
  45.             return print("task id:",task_id)
  46.  
  47.     def call(self, msg):
  48.         self.response = None
  49.         self.channel.basic_publish(exchange='',
  50.                                    routing_key='rpc_queue',
  51.                                    properties=pika.BasicProperties(
  52.                                        reply_to=self.callback_queue,
  53.                                        correlation_id=self.corr_id,
  54.                                    ),
  55.                                    body=msg)
  56.         self.connection.process_data_events()
  57.  
  58.     def check(self,cmd_list):
  59.         self.connection.process_data_events()
  60.         if self.task_dic.get(cmd_list[1]) is None:
  61.             return print("CMD is executing...")
  62.         return print(self.task_dic.get(cmd_list[1]))
  63.  
  64. exec_cmd = Cmd_RPC_Client()
  65. while True:
  66.     cmd = input(">>>:")
  67.     cmd_list = cmd.strip().split(" ")
  68.     print(cmd_list)
  69.     if hasattr(exec_cmd,cmd_list[0]):
  70.         func = getattr(exec_cmd,cmd_list[0])
  71.         func(cmd_list)
  72.  
  73. #  run "df -h" --host 1.1.1.1 2.2.22.2

Server端

  1. #Author:Ivor
  2. import pika
  3. import time,json
  4. import paramiko
  5.  
  6. connection = pika.BlockingConnection(pika.ConnectionParameters(
  7.     host='localhost'))
  8. channel = connection.channel()
  9. channel.queue_declare(queue='rpc_queue')
  10.  
  11. def ssh_cmd(msg):
  12.     res_msg = {}
  13.     hosts = msg.get("hosts")
  14.     task_id = msg.get("task_id")
  15.     cmd = msg.get("cmd")
  16.     ssh = paramiko.SSHClient()
  17.     ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  18.     for host in hosts:
  19.         # ssh.connect(hostname=host, port=22, username="root:", password="XXX")
  20.         # stdin, stdout, stderr = ssh.exec_command(cmd)
  21.         # result = stdout.read() if stdout.read() else stderr.read()
  22.         result = ""
  23.         res_msg[host] = result
  24.     ssh.close()
  25.     response = {
  26.         "task_id": task_id,
  27.         "res_msg":res_msg
  28.     }
  29.     response = json.dumps(response).encode()
  30.     return response
  31. def on_request(ch, method, props, body):
  32.     msg = json.loads(body.decode())
  33.     print(msg)
  34.     response = ssh_cmd(msg)
  35.     ch.basic_publish(exchange='',
  36.                      routing_key=props.reply_to,
  37.                      properties=pika.BasicProperties(
  38.                          correlation_id=props.correlation_id),
  39.                      body=response
  40.                      )
  41.     ch.basic_ack(delivery_tag=method.delivery_tag)
  42. # channel.basic_qos(prefetch_count=1)
  43. channel.basic_consume(on_request, queue='rpc_queue')
  44. channel.start_consuming()

Redis部分

redis

介绍

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

Redis优点

  • 异常快速 : Redis是非常快的，每秒可以执行大约110000设置操作，81000个/每秒的读取操作。

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

    这使得在应用中很容易解决的各种问题，因为我们知道哪些问题处理使用哪种数据类型更好解决。

  • 操作都是原子的 : 所有 Redis 的操作都是原子，从而确保当两个客户同时访问 Redis 服务器得到的是更新后的值（最新值）。

  • MultiUtility工具：Redis是一个多功能实用工具，可以在很多如：缓存，消息传递队列中使用（Redis原生支持发布/订阅），在应用程序中，如：Web应用程序会话，网站页面点击数等任何短暂的数据；

安装Redis环境

要在 Ubuntu 上安装 Redis，打开终端，然后输入以下命令：
  1. $sudo apt-get update
  2. $sudo apt-get install redis-server
这将在您的计算机上安装Redis

启动 Redis

  1. $redis-server

查看 redis 是否还在运行

  1. $redis-cli
这将打开一个 Redis 提示符，如下图所示：
  1. redis 127.0.0.1:6379>
在上面的提示信息中：127.0.0.1 是本机的IP地址，6379是 Redis 服务器运行的端口。现在输入 PING 命令，如下图所示：
  1. redis 127.0.0.1:6379> ping
  2. PONG
这说明现在你已经成功地在计算机上安装了 Redis。
 
 

Redis API使用

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

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

连接方式

1、操作模式

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

1
2
3
4
5
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实例共享一个连接池。

操作

1. String操作

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

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，位结束位置

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, 要追加的字符串

　　

2. Hash操作

hash表现形式上有些像pyhton中的dict,可以存储一组关联性较强的数据 ， 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)

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

 

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

3. list

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 表示永远阻塞

4.set集合操作

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)，从大到小排序

zrem(name, values)

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

zremrangebyrank(name, min, max)

1
# 根据排行范围删除

zremrangebyscore(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

 

管道

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

1
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)
 
pipe.set('name', 'alex')
pipe.set('role', 'sb')
 
pipe.execute()

 

发布订阅

发布者：服务器

订阅者：Dashboad和数据处理

Demo如下：

  1. import redis
  2.  
  3. class RedisHelper:
  4.  
  5.     def __init__(self):
  6.         self.__conn = redis.Redis(host='10.211.55.4')
  7.         self.chan_sub = 'fm104.5'
  8.         self.chan_pub = 'fm104.5'
  9.  
  10.     def public(self, msg):
  11.         self.__conn.publish(self.chan_pub, msg)
  12.         return True
  13.  
  14.     def subscribe(self):
  15.         pub = self.__conn.pubsub()
  16.         pub.subscribe(self.chan_sub)
  17.         pub.parse_response()
  18.         return pub

redis helper

订阅者：

1
2
3
4
5
6
7
8
9
10
11
#!/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

发布者：

1
2
3
4
5
6
7
#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
from monitor.RedisHelper import RedisHelper
 
obj = RedisHelper()
obj.public('hello')

 

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

http://doc.redisfans.com/

Python学习-day11 RabbitMQ Redis的更多相关文章

  1. python 学习分享-rabbitmq

    一.RabbitMQ 消息队列介绍 RabbitMQ也是消息队列,那RabbitMQ和之前python的Queue有什么区别么? py 消息队列: 线程 queue(同一进程下线程之间进行交互) 进程 ...

  2. python学习之-- RabbitMQ 消息队列

    记录:异步网络框架:twisted学习参考:www.cnblogs.com/alex3714/articles/5248247.html RabbitMQ 模块 <消息队列> 先说明:py ...

  3. python学习之操作redis

    一.Redis安装网上很多可以查找 二.redis-py的安装,使用命令pip install redis. 安装过程中如果产生连接超时的错误,可以使用国内镜像参考如下 豆瓣:pip install ...

  4. python学习 day11 (3月16日)----(生成器内置函数）

    1生成器 1生成器的本质 一定是迭代器(反之不一定(用send(生成器特有方法)验证))2生成器是可以让程序员自己定义的一个迭代器3生成器的好处,节省内存空间4生成器的特性,一次性的,惰性机制,从上往 ...

  5. python学习day11

    目录 SqlAlchemy 外键 SqlAlechemy SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象 ...

  6. Python学习之==>操作Redis

    一.redis简介 1.非关系型数据库 2.数据全部是存在内存里面 3.性能非常好,每秒支持30w次读写 4.可以通过备份数据库,把数据存到磁盘上来实现数据的持久化 二.操作redis 1.strin ...

  7. python学习之rabbitmq

    0.讲述rabbit中各部分的含义及作用 https://www.jb51.net/article/75647.htm 1.rabbitMQ的安装 1)在安装rabbitmq之前需要先安装erlang ...

  8. python学习day11 函数Ⅲ (内置函数与lambda表达式)

    函数Ⅲ(内置函数&lambda表达式) 1.函数小高级 函数可以当做变量来使用: def func(): print(123) func_list = [func, func, func] # ...

  9. python学习Day11 函数的参数列表

    复习 什么是函数? 具体特定功能的代码块 - 特定功能代码作为一个整体,并给该整体命名,就是函数 函数的优点 : 1.减少代码的冗余,2.结构清晰,可读性强 3.具有复用性,开发效率高,维护成本高 如 ...

随机推荐

  1. es6 随笔

    记录一些学习es6中学习的新特性,挺有用,作为日后复习es6用,便于记忆. 1.变量定义let和const es6用let.const代替,let是定义块级作用域中的变量,const声明之后必须赋值, ...

  2. python之字符串切割

    Python中split()函数,通常用于将字符串切片并转换为列表. 一.函数说明: split():语法:str.split(str="",num=string.count(st ...

  3. SqlServer图形数据库初体验

    SQL Server2017新增了一个新功能叫做图形数据库.图形指的拓扑图形,是一些Node表和Edge表的合集,Node对应关系数据库中的实体,比如一个人.一个岗位等,Edge表指示Node之前的关 ...

  4. Flexbox与Grid属性比较

    网格容器(container)属性 网格项目(item)属性 Flex容器(container)属性 Flex项目(item)属性

  5. HBuilder发行App（Android和ios）

    怎样将开发好的app测试和上架,此文包括Android和ios打包.测试和上架的大概过程.内容有些简陋,因为此过程踏坑无数,特此留念. 特此声明:内容不全仅供参考. 介绍两个参考网站: 1. http ...

  6. 论overflow滚动的重要性

    原理 设置一个块级作用域溢出的效果,只需要在外部块的位置上设置overflow:scroll和height:xx即可. 此时,块级作用域的内容位移超出外部块的位移就会出现滚动条,当内部块滚动时,我们能 ...

  7. python剑指offer 链表中环的入口节点

    题目: 一个链表中包含环,请找出该链表的环的入口结点. 思路: 先说个定理:两个指针一个fast.一个slow同时从一个链表的头部出发, fast一次走2步,slow一次走一步,如果该链表有环,两个指 ...

  8. Nginx学习记录(二)

    1. 什么是反向代理 正向代理 反向代理: 反向代理服务器决定哪台服务器提供服务. 返回代理服务器不提供服务器.也是请求的转发. 反向代理(Reverse Proxy)方式是指以代理服务器来接受Int ...

  9. Angular2的笔记

    1.如果启动项目的时候出现下列黄色的警告说明电脑安装的全局cli和项目中使用的cli版本不一致,不过不影响使用,按它的提示执行 ng set --global warnings.versionMism ...

  10. C++的XML编程经验――LIBXML2库使用指南

    C++的XML编程经验――LIBXML2库使用指南 写这篇文章的原因有如下几点:1)C++标准库中没有操作XML的方法,用C++操作XML文件必须熟悉一种函数库,LIBXML2是其中一种很优秀的XML ...