二、          手机效果显示

这本书我看了电子版的,感觉还不错,全书共有20章,书中的简介如下:

Publish\Subscrible(消息发布\订阅)

前面都是1对1的发送接收数据,那我想1对多,想广播一样,生产者发送一个消息,所有消费者都收到消息。那我们怎么做呢?这个时候我们就要用到exchange了

exchange在一端收消息,在另一端就把消息放进queue,exchange必须精确的知道收到的消息要干什么,是否应该发到一个特定的queue还是发给许多queue,或者说把他丢弃,这些都被exchange的类型所定义

exchange在定义的时候是有类型的,以决定到底是那些queue符合条件,可以接受消息:

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

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

topic:所有符合routingKey的routingKey所bind的queue可以接受消息

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

消息publisher:

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

 

这里的exchange之前是空的,现在赋值log;在这里也没有声明queue,广播不需要写queue

 消息subscriber:

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

 

在消费者这里我们有定义了一个queue,注意一下注释中的内容。但是我们在发送端没有声明queue,为什么发送端不需要接收端需要呢?在consume里有一个channel.queue_bind()函数,里面绑定了exchange转换器上,当然里面还需要一个queue_name

运行结果:

图片 1图片 2图片 3图片 4

就相当于收音机一样,实时广播,打开三个消费者,生产者发送一条数据,然后3个消费者同时接收到

图 2设置界面

需要学习的朋友可以通过网盘下载pdf版
第 1 章 起步
1.1  搭建编程环境
1.1.1   Python 2 和 Python 3
1.1.2  运行 Python 代码片段
1.1.3   Hello World 程序
1.2  在不同操作系统中搭建 Python 编程环境
1.2.1  在 Linux 系统中搭建 Python 编程环境
1.2.2  在 OS X 系统中搭建 Python 编程环境
1.2.3  在 Windows 系统中搭建 Python 编程环境
1.3  解决安装问题
1.4  从终端运行 Python 程序
1.4.1  在 Linux 和 OS X 系统中从终端运行 Python 程序
1.4.2  在 Windows 系统中从终端运行 Python 程序
1.5  小结
第 2 章 变量和简单数据类型
2.1  运行 hello_world.py 时发生的情况
2.2  变量
2.2.1  变量的命名和使用
2.2.2  使用变量时避免命名错误
2.3  字符串
2.3.1  使用方法修改字符串的大小写
2.3.2  合并(拼接)字符串
2.3.3  使用制表符或换行符来添加空白
2.3.4  删除空白
2.3.5  使用字符串时避免语法错误
2.3.6   Python 2 中的 print 语句
2.4  数字
2.4.1  整数
2.4.2  浮点数
2.4.3  使用函数 str() 避免类型错误
2.4.4   Python 2 中的整数
2.5  注释
2.5.1  如何编写注释
2.5.2  该编写什么样的注释
2.6   Python 之禅
2.7  小结
第 3 章 列表简介
3.1  列表是什么
3.1.1  访问列表元素
3.1.2  索引从 0 而不是 1 开始
3.1.3  使用列表中的各个值
3.2  修改、添加和删除元素
3.2.1  修改列表元素
3.2.2  在列表中添加元素
3.2.3  从列表中删除元素
3.3  组织列表
3.3.1  使用方法 sort() 对列表进行永久性排序
3.3.2  使用函数 sorted() 对列表进行临时排序
3.3.3  倒着打印列表
3.3.4  确定列表的长度
3.4  使用列表时避免索引错误
3.5  小结
第 4 章 操作列表
4.1  遍历整个列表
4.1.1  深入地研究循环
4.1.2  在 for 循环中执行更多的操作
4.1.3  在 for 循环结束后执行一些操作
4.2  避免缩进错误
4.2.1  忘记缩进
4.2.2  忘记缩进额外的代码行
4.2.3  不必要的缩进
4.2.4  循环后不必要的缩进
4.2.5  遗漏了冒号
4.3  创建数值列表
4.3.1  使用函数 range()
4.3.2  使用 range() 创建数字列表
4.3.3  对数字列表执行简单的统计计算
4.3.4  列表解析
4.4  使用列表的一部分
4.4.1  切片
4.4.2  遍历切片
4.4.3  复制列表
4.5  元组
4.5.1  定义元组
4.5.2  遍历元组中的所有值
4.5.3  修改元组变量
4.6  设置代码格式
4.6.1  格式设置指南
4.6.2  缩进
4.6.3  行长
4.6.4  空行
4.6.5  其他格式设置指南
4.7  小结
第 5 章  if 语句
5.1  一个简单示例
5.2  条件测试
5.2.1  检查是否相等
5.2.2  检查是否相等时不考虑大小写
5.2.3  检查是否不相等
5.2.4  比较数字
5.2.5  检查多个条件
5.2.6  检查特定值是否包含在列表中
5.2.7  检查特定值是否不包含在列表中
5.2.8  布尔表达式
5.3   if 语句
5.3.1  简单的 if 语句
5.3.2   if-else 语句
5.3.3   if-elif-else 结构
5.3.4  使用多个 elif 代码块
5.3.5  省略 else 代码块
5.3.6  测试多个条件
5.4  使用 if 语句处理列表
5.4.1  检查特殊元素
5.4.2  确定列表不是空的
5.4.3  使用多个列表
5.5  设置 if 语句的格式
5.6  小结
第 6 章 字典
6.1  一个简单的字典
6.2  使用字典
6.2.1  访问字典中的值
6.2.2  添加键 — 值对
6.2.3  先创建一个空字典
6.2.4  修改字典中的值
6.2.5  删除键 — 值对
6.2.6  由类似对象组成的字典
6.3  遍历字典
6.3.1  遍历所有的键 — 值对
6.3.2  遍历字典中的所有键
6.3.3  按顺序遍历字典中的所有键
6.3.4  遍历字典中的所有值
6.4  嵌套
6.4.1  字典列表
6.4.2  在字典中存储列表
6.4.3  在字典中存储字典
6.5  小结
第 7 章 用户输入和 while 循环
7.1  函数 input() 的工作原理
7.1.1  编写清晰的程序
7.1.2  使用 int() 来获取数值输入
7.1.3  求模运算符
7.1.4  在 Python 2.7 中获取输入
7.2   while 循环简介
7.2.1  使用 while 循环
7.2.2  让用户选择何时退出
7.2.3  使用标志
7.2.4  使用 break 退出循环
7.2.5  在循环中使用 continue
7.2.6  避免无限循环
7.3  使用 while 循环来处理列表和字典
7.3.1  在列表之间移动元素
7.3.2  删除包含特定值的所有列表元素
7.3.3  使用用户输入来填充字典
7.4  小结
第 8 章 函数
8.1  定义函数
8.1.1  向函数传递信息
8.1.2  实参和形参
8.2  传递实参
8.2.1  位置实参
8.2.2  关键字实参
8.2.3  默认值
8.2.4  等效的函数调用
8.2.5  避免实参错误
8.3  返回值
8.3.1  返回简单值
8.3.2  让实参变成可选的
8.3.3  返回字典
8.3.4  结合使用函数和 while 循环
8.4  传递列表
8.4.1  在函数中修改列表
8.4.2  禁止函数修改列表
8.5  传递任意数量的实参
8.5.1  结合使用位置实参和任意数量实参
8.5.2  使用任意数量的关键字实参
8.6  将函数存储在模块中
8.6.1  导入整个模块
8.6.2  导入特定的函数
8.6.3  使用 as 给函数指定别名
8.6.4  使用 as 给模块指定别名
8.6.5  导入模块中的所有函数
8.7  函数编写指南
8.8  小结
第 9 章 类
9.1  创建和使用类
9.1.1  创建 Dog 类
9.1.2  根据类创建实例
9.2  使用类和实例
9.2.1   Car 类
9.2.2  给属性指定默认值
9.2.3  修改属性的值
9.3  继承
9.3.1  子类的方法 __init__()
9.3.2   Python 2.7 中的继承
9.3.3  给子类定义属性和方法
9.3.4  重写父类的方法
9.3.5  将实例用作属性
9.3.6  模拟实物
9.4  导入类
9.4.1  导入单个类
9.4.2  在一个模块中存储多个类
9.4.3  从一个模块中导入多个类
9.4.4  导入整个模块
9.4.5  导入模块中的所有类
9.4.6  在一个模块中导入另一个模块
9.4.7  自定义工作流程
9.5   Python 标准库
9.6  类编码风格
9.7  小结
第 10 章 文件和异常
10.1  从文件中读取数据
10.1.1  读取整个文件
10.1.2  文件路径
10.1.3  逐行读取
10.1.4  创建一个包含文件各行内容的列表
10.1.5  使用文件的内容
10.1.6  包含一百万位的大型文件
10.1.7  圆周率值中包含你的生日吗
10.2  写入文件
10.2.1  写入空文件
10.2.2  写入多行
10.2.3  附加到文件
10.3  异常
10.3.1  处理 ZeroDivisionError 异常
10.3.2  使用 try-except 代码块
10.3.3  使用异常避免崩溃
10.3.4   else 代码块
10.3.5  处理 FileNotFoundError 异常
10.3.6  分析文本
10.3.7  使用多个文件
10.3.8  失败时一声不吭
10.3.9  决定报告哪些错误
10.4  存储数据
10.4.1  使用 json.dump() 和 json.load()
10.4.2  保存和读取用户生成的数据
10.4.3  重构
10.5  小结
第 11 章 测试代码
11.1  测试函数
11.1.1  单元测试和测试用例
11.1.2  可通过的测试
11.1.3  不能通过的测试
11.1.4  测试未通过时怎么办
11.1.5  添加新测试
11.2  测试类
11.2.1  各种断言方法
11.2.2  一个要测试的类
11.2.3  测试 AnonymousSurvey 类
11.2.4  方法 setUp()
11.3  小结
第二部分 项目
项目 1  外星人入侵
第 12 章 武装飞船
12.1  规划项目
12.2  安装 Pygame
12.2.1  使用 pip 安装 Python 包
12.2.2  在 Linux 系统中安装 Pygame
12.2.3  在 OS X 系统中安装 Pygame
12.2.4  在 Windows 系统中安装 Pygame
12.3  开始游戏项目
12.3.1  创建 Pygame 窗口以及响应用户输入
12.3.2  设置背景色
12.3.3  创建设置类
12.4  添加飞船图像
12.4.1  创建 Ship 类
12.4.2  在屏幕上绘制飞船
12.5  重构:模块 game_functions
12.5.1  函数 check_events()
12.5.2  函数 update_screen()
12.6  驾驶飞船
12.6.1  响应按键
12.6.2  允许不断移动
12.6.3  左右移动
12.6.4  调整飞船的速度
12.6.5  限制飞船的活动范围
12.6.6  重构 check_events()
12.7  简单回顾
12.7.1   alien_invasion.py
12.7.2   settings.py
12.7.3   game_functions.py
12.7.4   ship.py
12.8  射击
12.8.1  添加子弹设置
12.8.2  创建 Bullet 类
12.8.3  将子弹存储到编组中
12.8.4  开火
12.8.5  删除已消失的子弹
12.8.6  限制子弹数量
12.8.7  创建函数 update_bullets()
12.8.8  创建函数 fire_bullet()
12.9  小结
第 13 章 外星人
13.1  回顾项目
13.2  创建第一个外星人
13.2.1  创建 Alien 类
13.2.2  创建 Alien 实例
13.2.3  让外星人出现在屏幕上
13.3  创建一群外星人
13.3.1  确定一行可容纳多少个外星人
13.3.2  创建多行外星人
13.3.3  创建外星人群
13.3.4  重构 create_fleet()
13.3.5  添加行
13.4  让外星人群移动
13.4.1  向右移动外星人
13.4.2  创建表示外星人移动方向的设置
13.4.3  检查外星人是否撞到了屏幕边缘
13.4.4  向下移动外星人群并改变移动方向
13.5  射杀外星人
13.5.1  检测子弹与外星人的碰撞
13.5.2  为测试创建大子弹
13.5.3  生成新的外星人群
13.5.4  提高子弹的速度
13.5.5  重构 update_bullets()
13.6  结束游戏
13.6.1  检测外星人和飞船碰撞
13.6.2  响应外星人和飞船碰撞
13.6.3  有外星人到达屏幕底端
13.6.4  游戏结束
13.7  确定应运行游戏的哪些部分
13.8  小结
记分
14.1  添加 Play 按钮
14.1.1  创建 Button 类
14.1.2  在屏幕上绘制按钮
14.1.3  开始游戏
14.1.4  重置游戏
14.1.5  将 Play 按钮切换到非活动状态
14.1.6  隐藏光标
14.2  提高等级
14.2.1  修改速度设置
14.2.2  重置速度
14.3  记分
14.3.1  显示得分
14.3.2  创建记分牌
14.3.3  在外星人被消灭时更新得分
14.3.4  将消灭的每个外星人的点数都计入得分
14.3.5  提高点数
14.3.6  将得分圆整
14.3.7  最高得分
14.3.8  显示等级
14.3.9  显示余下的飞船数
14.4  小结
项目 2  数据可视化
第 15 章 生成数据
15.1  安装 matplotlib
15.1.1  在 Linux 系统中安装 matplotlib
15.1.2  在 OS X 系统中安装 matplotlib
15.1.3  在 Windows 系统中安装 matplotlib
15.1.4  测试 matplotlib
15.1.5   matplotlib 画廊
15.2  绘制简单的折线图
15.2.1  修改标签文字和线条粗细
15.2.2  校正图形
15.2.3  使用 scatter() 绘制散点图并设置其样式
15.2.4  使用 scatter() 绘制一系列点
15.2.5  自动计算数据
15.2.6  删除数据点的轮廓
15.2.7  自定义颜色
15.2.8  使用颜色映射
15.2.9  自动保存图表
15.3  随机漫步
15.3.1  创建 RandomWalk() 类
15.3.2  选择方向
15.3.3  绘制随机漫步图
15.3.4  模拟多次随机漫步
15.3.5  设置随机漫步图的样式
15.3.6  给点着色
15.3.7  重新绘制起点和终点
15.3.8  隐藏坐标轴
15.3.9  增加点数
15.3.10  调整尺寸以适合屏幕
15.4  使用 Pygal 模拟掷骰子
15.4.1  安装 Pygal
15.4.2   Pygal 画廊
15.4.3  创建 Die 类
15.4.4  掷骰子
15.4.5  分析结果
15.4.6  绘制直方图
15.4.7  同时掷两个骰子
15.4.8  同时掷两个面数不同的骰子
15.5  小结
第 16 章 下载数据
16.1   CSV 文件格式
16.1.1  分析 CSV 文件头
16.1.2  打印文件头及其位置
16.1.3  提取并读取数据
16.1.4  绘制气温图表
16.1.5  模块 datetime
16.1.6  在图表中添加日期
16.1.7  涵盖更长的时间
16.1.8  再绘制一个数据系列
16.1.9  给图表区域着色
16.1.10  错误检查
16.2  制作世界人口地图: JSON 格式
16.2.1  下载世界人口数据
16.2.2  提取相关的数据
16.2.3  将字符串转换为数字值
16.2.4  获取两个字母的国别码
16.2.5  制作世界地图
16.2.6  在世界地图上呈现数字数据
16.2.7  绘制完整的世界人口地图
16.2.8  根据人口数量将国家分组
16.2.9  使用 Pygal 设置世界地图的样式
16.2.10  加亮颜色主题
16.3  小结
第 17 章 使用 API
17.1  使用 Web API
17.1.1   Git 和 GitHub
17.1.2  使用 API 调用请求数据
17.1.3  安装 requests
17.1.4  处理 API 响应
17.1.5  处理响应字典
17.1.6  概述最受欢迎的仓库
17.1.7  监视 API 的速率限制
17.2  使用 Pygal 可视化仓库
17.2.1  改进 Pygal 图表
17.2.2  添加自定义工具提示
17.2.3  根据数据绘图
17.2.4  在图表中添加可单击的链接
17.3   Hacker News API
17.4  小结
项目 3   Web 应用程序
第 18 章  Django 入门
18.1  建立项目
18.1.1  制定规范
18.1.2  建立虚拟环境
18.1.3  安装 virtualenv
18.1.4  激活虚拟环境
18.1.5  安装 Django
18.1.6  在 Django 中创建项目
18.1.7  创建数据库
18.1.8  查看项目
18.2  创建应用程序
18.2.1  定义模型
18.2.2  激活模型
18.2.3   Django 管理网站
18.2.4  定义模型 Entry
18.2.5  迁移模型 Entry
18.2.6  向管理网站注册 Entry
18.2.7   Django shell
18.3  创建网页:学习笔记主页
18.3.1  映射 URL
18.3.2  编写视图
18.3.3  编写模板
18.4  创建其他网页
18.4.1  模板继承
18.4.2  显示所有主题的页面
18.4.3  显示特定主题的页面
18.5  小结
第 19 章 用户账户
19.1  让用户能够输入数据
19.1.1  添加新主题
19.1.2  添加新条目
19.1.3  编辑条目
19.2  创建用户账户
19.2.1  应用程序 users
19.2.2  登录页面
19.2.3  注销
19.2.4  注册页面
19.3  让用户拥有自己的数据
19.3.1  使用 @login_required 限制访问
19.3.2  将数据关联到用户
19.3.3  只允许用户访问自己的主题
19.3.4  保护用户的主题
19.3.5  保护页面 edit_entry
19.3.6  将新主题关联到当前用户
19.4  小结
第 20 章 设置应用程序的样式并对其进行部署
20.1  设置项目 “ 学习笔记 ” 的样式
20.1.1  应用程序 django-bootstrap3
20.1.2  使用 Bootstrap 来设置项目 “ 学习笔记 ” 的样式
20.1.3  修改 base.html
20.1.4  使用 jumbotron 设置主页的样式
20.1.5  设置登录页面的样式
20.1.6  设置 new_topic 页面的样式
20.1.7  设置 topics 页面的样式
20.1.8  设置 topic 页面中条目的样式
20.2  部署 “ 学习笔记 ”
20.2.1  建立 Heroku 账户
20.2.2  安装 Heroku Toolbelt
20.2.3  安装必要的包
20.2.4  创建包含包列表的文件 requirements.txt
20.2.5  指定 Python 版本
20.2.6  为部署到 Herohu 而修改 settings.py
20.2.7  创建启动进程的 Procfile
20.2.8  为部署到 Herohu 而修改 wsgi.py
20.2.9  创建用于存储静态文件的目录
20.2.10  在本地使用 gunicorn 服务器
20.2.11  使用 Git 跟踪项目文件
20.2.12  推送到 Heroku
20.2.13  在 Heroku 上建立数据库
20.2.14  改进 Heroku 部署
20.2.15  确保项目的安全
20.2.16  提交并推送修改
20.2.17  创建自定义错误页面
20.2.18  继续开发
20.2.19  设置 SECRET_KEY
20.2.20  将项目从 Heroku 删除
20.3  小结
附录 A  安装 Python
A.1  在 Linux 系统中安装 Python
A.1.1  确定已安装的版本
A.1.2  在 Linux 系统中安装 Python 3
A.2  在 OS X 系统中安装 Python
A.2.1  确定已安装的版本
A.2.2  使用 Homebrew 来安装 Python 3
A.3  在 Windows 系统中安装 Python
A.3.1  在 Windows 系统中安装 Python 3
A.3.2  查找 Python 解释器
A.3.3  将 Python 添加到环境变量 Path 中
A.4   Python 关键字和内置函数
A.4.1   Python 关键字
A.4.2   Python 内置函数
附录 B  文本编辑器
B.1   Geany
B.1.1  在 Linux 系统中安装 Geany
B.1.2  在 Windows 系统中安装 Geany
B.1.3  在 Geany 中运行 Python 程序
B.1.4  定制 Geany 的设置
B.2   Sublime Text
B.2.1  在 OS X 系统中安装 Sublime Text
B.2.2  在 Linux 系统中安装 Sublime Text
B.2.3  在 Windows 系统中安装 Sublime Text
B.2.4  在 Sublime Text 中运行 Python 程序
B.2.5  配置 Sublime Text
B.2.6  定制 Sublime Text 的设置
B.3   IDLE
B.3.1  在 Linux 系统中安装 IDLE
B.3.2  在 OS X 系统中安装 IDLE
B.3.3  在 Windows 系统中安装 IDLE
B.3.4  定制 IDLE 的设置
B.4   Emacs 和 vim
附录 C  寻求帮助
C.1  第一步
C.1.1  再试试
C.1.2  歇一会儿
C.1.3  参考本书的在线资源
C.2  在线搜索
C.2.1   Stack Overflow
C.2.2   Python 官方文档
C.2.3  官方库文档
C.2.4   r/learnpython
C.2.5  博客
C.3   IRC
C.3.1  创建 IRC 账户
C.3.2  加入频道
C.3.3   IRC 文化
附录 D  使用 Git 进行版本控制
D.1  安装 Git
D.1.1  在 Linux 系统中安装 Git
D.1.2  在 OS X 系统中安装 Git
D.1.3  在 Windows 系统中安装 Git
D.1.4  配置 Git
D.2  创建项目
D.3  忽略文件
D.4  初始化仓库
D.5  检查状态
D.6  将文件加入到仓库中
D.7  执行提交
D.8  查看提交历史
D.9  第二次提交
D.10  撤销修改
D.11  检出以前的提交
D.12  删除仓库

RabbitMQ队列

首先我们在讲rabbitMQ之前我们要说一下python里的queue:二者干的事情是一样的,都是队列,用于传递消息

在python的queue中有两个一个是线程queue,一个是进程queue(multiprocessing中的queue)。线程queue不能够跨进程,用于多个线程之间进行数据同步交互;进程queue只是用于父进程与子进程,或者同属于同意父进程下的多个子进程
进行交互。也就是说如果是两个完全独立的程序,即使是python程序,也依然不能够用这个进程queue来通信。那如果我们有两个独立的python程序,分属于两个进程,或者是python和其他语言

安装:windows下

首先需要安装 Erlang环境

官网: 

Windows版下载地址:

Linux版:     使用yum安装

 

然后安装RabbitMQ了 

首先下载RabbitMQ 的Windows版本

下载地址:

安装pika:

之前安装过了pip,直接打开cmd,运行pip install pika

安装完毕之后,实现一个最简单的队列通信:

图片 5

producer:

 1 import pika
 2 
 3 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
 4 #声明一个管道
 5 channel = connection.channel()
 6 
 7 #声明queue
 8 channel.queue_declare(queue = 'hello')
 9 #routing_key是queue的名字
10 channel.basic_publish(exchange='',
11                       routing_key='hello',#queue的名字
12                       body='Hello World!',
13                       )
14 print("[x] Send 'Hello World!'")
15 connection.close()

 

先建立一个基本的socket,然后建立一个管道,在管道中发消息,然后声明一个queue,起个队列的名字,之后真正的发消息(basic_publish)

consumer:

 1 import pika
 2 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
 3 channel = connection.channel()
 4 
 5 channel.queue_declare(queue='hello')
 6 
 7 
 8 def callback(ch, method, properties, body):#回调函数
 9     print("---->",ch,method,properties)
10     print(" [x] Received %r" % body)
11 
12 channel.basic_consume(callback,#如果收到消息,就调用callback来处理消息
13                       queue='hello',
14                       no_ack=True
15                        )
16 
17 print(' [*] Waiting for messages. To exit press CTRL+C')
18 channel.start_consuming()

 

 start_consuming()只要一启动就一直运行下去,他不止收一条,永远在这里卡住。

在上面不管是produce还是consume,里面都声明了一个queue,这个是为什么呢?因为我们不知道是消费者先开始运行还是生产者先运行,这样如果没有声明的话就会报错。

下面我们来看一下一对多,即一个生产者对应多个消费者:

首先我们运行3个消费者,然后不断的用produce去发送数据,我们可以看到消费者是通过一种轮询的方式进行不断的接受数据,每个消费者消费一个。

那么假如我们消费者收到了消息,然后处理这个消息需要30秒钟,在处理的过程中,消费者断电了宕机了,那消费者还没有处理完,我们设这个任务我们必须处理完,那我们应该有一个确认的信息,说这个任务完成了或者是没有完成,所以我的生产者要确认消费者是否把这个任务处理完了,消费者处理完之后要给这个生产者服务器端发送一个确认信息,生产者才会把这个任务从消息队列中删除。如果没有处理完,消费者宕机了,没有给生产者发送确认信息,那就表示没有处理完,那我们看看rabbitMQ是怎么处理的

我们可以在消费者的callback中添加一个time.sleep()进行模拟宕机。callback是一个回调函数,只要事件一触发就会调用这个函数。函数执行完了就代表消息处理完了,如果函数没有处理完,那就说明。。。。

我们可以看到在消费者代码中的basic_consume()中有一个参数叫no_ack=True,这个意思是这条消息是否被处理完都不会发送确认信息,一般我们不加这个参数,rabbitMQ默认就会给你设置成消息处理完了就自动发送确认,我们现在把这个参数去掉,并且在callback中添加一句话运行:ch.basic_ack(delivery_tag=method.delivery_tag)(手动处理)

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)

 

图片 6图片 7图片 8

运行的结果就是,我先运行一次生产者,数据被消费者1接收到了,但是我把消费者1宕机,停止运行,那么消费者2就接到了消息,即只要消费者没有发送确认信息,生产者就不会把信息删除。

RabbitMQ消息持久化:

我们可以生成好多的消息队列,那我们怎么查看消息队列的情况呢:rabbitmqctl.bat
list_queues

图片 9

现在的情况是,消息队列中还有消息,但是服务器宕机了,那这个消息就丢了,那我就需要这个消息强制的持久化:

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

 

在每次声明队列的时候加上一个durable参数(客户端和服务器端都要加上这个参数),

图片 10

在这个情况下,我们把rabbitMQ服务器重启,发现只有队列名留下了,但是队列中的消息没有了,这样我们还需要在生产者basic_publish中添加一个参数:properties

producer:

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
#声明一个管道
channel = connection.channel()

#声明queue
channel.queue_declare(queue = 'hello2',durable=True)
#routing_key是queue的名字
channel.basic_publish(exchange='',
                      routing_key='hello2',
                      body='Hello World!',
                      properties=pika.BasicProperties(
                          delivery_mode=2,#make message persistent
                      )
                      )
print("[x] Send 'Hello World!'")
connection.close()

 

这样就可以使得消息持久化

现在是一个生产者对应三个消费者,很公平的收发收发,但是实际的情况是,我们机器的配置是不一样的,有的配置是单核的有的配置是多核的,可能i7处理器处理4条消息的时候和其他的处理器处理1条消息的时间差不多,那差的处理器那里就会堆积消息,而好的处理器那里就会形成闲置,在现实中做运维的,我们会在负载均衡中设置权重,谁的配置高权重高,任务就多一点,但是在rabbitMQ中,我们只做了一个简单的处理就可以实现公平的消息分发,你有多大的能力就处理多少消息

即:server端给客户端发送消息的时候,先检查现在还有多少消息,如果当前消息没有处理完毕,就不会发送给这个消费者消息。如果当前的消费者没有消息就发送

这个只需要在消费者端进行修改加代码:

import pika
import time
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

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


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)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(callback,#如果收到消息,就调用callback来处理消息
                      queue='hello2',
                      #no_ack=False
                       )

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

 

 我们在生成一个consume2,在callback中sleep20秒来模拟

图片 11图片 12图片 13

我先启动两个produce,被consume接受,然后在启动一个,就被consumer2接受,但是因为consumer2中sleep20秒,处理慢,所以这时候在启动produce,就又给了consume进行处理

 

  1. Mode属性

本书旨在让你成为优秀的程序员,具体地说,是优秀的 Python
程序员。通过阅读本书,你将迅速掌握编程概念,打下坚实的基础,并养成良好的习惯。阅读本书后,你就可以开始
学习 Python 高级技术,并能够更轻松地掌握其他编程语言。
在本书的第一部分,你将学习编写 Python
程序时需要熟悉的基本编程概念,你刚接触几乎任何编程语言时都需要学习这些概念。你将学习各种数据以及在程序中将数据存储到列表
和字典中的方式。你将学习如何创建数据集合以及如何高效地遍历这些集合。你将学习使用
while 和 if
语句来检查条件,并在条件满足时执行代码的一部分,而在条件不满足
时执行代码的另一部分 —— 这可为自动完成处理提供极大的帮助。
你将学习获取用户输入,让程序能够与用户交互,并在用户没停止输入时保持运行状态。你将探索如何编写函数来让程序的各个部分可重用,这样你编写执行特定任务的代码
后,想使用它多少次都可以。然后,你将学习使用类来扩展这种概念以实现更复杂的行为,从而让非常简单的程序也能处理各种不同的情形。你将学习编写妥善处理常见错误的
程序。学习这些基本概念后,你就能编写一些简短的程序来解决一些明确的问题。最后,你将向中级编程迈出第一步,学习如何为代码编写测试,以便在进一步改进程序时不用
担心可能引入 bug 。第一部分介绍的知识让你能够开发更大、更复杂的项目。
在第二部分,你将利用在第一部分学到的知识来开发三个项目。你可以根据自己的情况,以最合适的顺序完成这些项目;你也可以选择只完成其中的某些项目。在第一个项目
(第 12~14
章)中,你将创建一个类似于《太空入侵者》的射击游戏。这个游戏名为《外星人入侵》,它包含多个难度不断增加的等级。完成这个项目后,你就能够自己动手开发
2D 游戏了。
第二个项目(第 15~17
章)介绍数据可视化。数据科学家的目标是通过各种可视化技术来搞懂海量信息。你将使用通过代码生成的数据集、已经从网络下载下来的数据集以及程序
自动下载的数据集。完成这个项目后,你将能够编写能对大型数据集进行筛选的程序,并以可视化方式将筛选出来的数据呈现出来。
在第三个项目(第 18~20 章)中,你将创建一个名为 “ 学习笔记 ” 的小型 Web
应用程序。这个项目能够让用户将学到的与特定主题相关的概念记录下来。你将能够分别记录不同的主
题,还可以让其他人建立账户并开始记录自己的学习笔记。你还将学习如何部署这个项目,让任何人都能够通过网络访问它,而不管他身处何方。

有选择的接收消息(exchange_type = direct)

RabbitMQ还支持根据关键字发送,即:队列绑定关键字,发送者将数据根据关键字发送到消息exchange,exchange根据关键字判定应该将数据发送到指定的队列

图片 14

publisher:

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

 

subscriber:

import pika
import sys
connect = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connect.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()

 

更加细致的过滤(exchange_type=topic)

图片 15

 

publish:

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

 

subscriber:

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

 

 

以上都是服务器端发消息,客户端收消息,消息流是单向的,那如果我们想要发一条命令给远程的客户端去执行,然后想让客户端执行的结果返回,则这种模式叫做rpc

RabbitMQ RPC

图片 16

rpc server:

 1 import pika
 2 import time
 3 connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
 4 channel = connection.channel()
 5 
 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 
15 def on_request(ch,method,props,body):
16     n = int(body)
17     print("[.] fib(%s)" %n)
18     response = fib(n)
19 
20     ch.basic_publish(exchange='',routing_key=props.reply_to,
21                      properties=pika.BasicProperties(correlation_id=props.correlation_id),
22                      body = str(response))
23     ch.basic_ack(delivery_tag=method.delivery_tag)25 channel.basic_consume(on_request,queue='rpc_queue')
26 
27 print("[x] Awaiting rpc requests")
28 channel.start_consuming()

 

 

rpc client:

 1 import pika
 2 import uuid,time
 3 class FibonacciRpcClient(object):
 4     def __init__(self):
 5         self.connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
 6 
 7         self.channel = self.connection.channel()
 8 
 9         result = self.channel.queue_declare(exclusive=True)
10         self.callback_queue =  result.method.queue
11 
12         self.channel.basic_consume(self.on_response,#回调函数,只要一收到消息就调用
13                                    no_ack=True,queue=self.callback_queue)
14 
15     def on_response(self,ch,method,props,body):
16         if self.corr_id == props.correlation_id:
17             self.response = body
18 
19     def call(self,n):
20         self.response = None
21         self.corr_id = str(uuid.uuid4())
22         self.channel.basic_publish(exchange='',routing_key='rpc_queue',
23                                    properties=pika.BasicProperties(
24                                        reply_to=self.callback_queue,
25                                        correlation_id=self.corr_id
26                                    ),
27                                    body=str(n),#传的消息,必须是字符串
28                                    )
29         while self.response is None:
30             self.connection.process_data_events()#非阻塞版的start_consuming
31             print("no message....")
32             time.sleep(0.5)
33         return int(self.response)
34 fibonacci_rpc = FibonacciRpcClient()
35 print("[x] Requesting fib(30)")
36 response = fibonacci_rpc.call(30)
37 print("[.] Got %r"%response)

 

之前的start_consuming是进入一个阻塞模式,没有消息就等待消息,有消息就收过来

self.connection.process_data_events()是一个非阻塞版的start_consuming,就是说发了一个东西给客户端,每过一点时间去检查有没有消息,如果没有消息,可以去干别的事情

reply_to = self.callback_queue是用来接收反应队列的名字

corr_id =
str(uuid.uuid4()),correlation_id第一在客户端会通过uuid4生成,第二在服务器端返回执行结果的时候也会传过来一个,所以说如果服务器端发过来的correlation_id与自己的id相同
,那么服务器端发出来的结果就肯定是我刚刚客户端发过去的指令的执行结果。现在就一个服务器端一个客户端,无所谓缺人不确认。现在客户端是非阻塞版的,我们可以不让它打印没有消息,而是执行新的指令,这样就两条消息,不一定按顺序完成,那我们就需要去确认每个返回的结果是哪个命令的执行结果。

总体的模式是这样的:生产者发了一个命令给消费者,不知道客户端什么时候返回,还是要去收结果的,但是它又不想进入阻塞模式,想每过一段时间看这个消息收回来没有,如果消息收回来了,就代表收完了。 

运行结果:

图片 17图片 18

服务器端开启,然后在启动客户端,客户端先是等待消息的发送,然后做出反应,直到算出斐波那契

 

 

 

 

 

 

 

 

 

 

图 1设置界面

本书旨在让你尽快学会 Python ,以便能够编写能正确运行的程序 ——
游戏、数据可视化和 Web
应用程序,同时掌握让你终身受益的基本编程知识。本书适合任何年龄的读者阅读,
它不要求你有任何 Python
编程经验,甚至不要求你有编程经验。如果你想快速掌握基本的编程知识以便专注于开发感兴趣的项目,并想通过解决有意义的问题来检查你对新学概念
的理解程度,那么本书就是为你编写的。本书还可供初中和高中教师用来通过开发项目向学生介绍编程。

让控件显示在合适的位置(3, 153),如图 3;

让GifView控件大小为(25, 25),如图 5;

获取或设置获取图像模式,默认设置为“File”,表示直接从文件中读取图像,如图
4;

获取和设置是否自动重复播放Gif动画,将该属性设置为“True”,如图 2;

我们要实现上图中的效果,需要如下的操作:

  1. Location属性

图片 19 

发表评论

电子邮件地址不会被公开。 必填项已用*标注