精华内容
下载资源
问答
  • 基于ARM内核STM32F4开发(环境IAR),或MSP430。 基于InvenSense公司MPL库,使用DMP数字动作处理加速器。...使用Python客户端监控可视化图象3D图象,打印MPU6050数据,欧拉角、重力加速度或其他原始数据。
  • 实时堆栈追踪(stacktrace) ...Heartrate 是一个 Python 的工具库,可以实时可视化 Python 程序的执行过程。监控运行中的 Python 程序如图: 如图所示,左侧数字表示每行代码被触发的次数。长方框表示...

    实时堆栈追踪(stacktrace)

     

    Heartate——如监测心率般追踪程序运行

    项目地址:https://github.com/alexmojaki/heartrate

     

    Heartrate 是一个 Python 的工具库,可以实时可视化 Python 程序的执行过程。监控运行中的 Python 程序如图:

     

    如图所示,左侧数字表示每行代码被触发的次数。长方框表示最近被触发的代码行——方框越长表示触发次数越多,颜色越浅表示最近被触发次数越多。

     

    该工具可以做什么:

     

    • 启动程序追踪

    • 在线程中启动服务器

    • 打开显示 trace() 被调用的文件可视化图的浏览器窗口

     

    代码调用高亮依赖于executing (https://github.com/alexmojaki/executing) 库,同时由于版本原因,hearttrate只支持Python3.5以上版本,pip安装如下:

     

    pip install --user heartrate

    展开全文
  • 2019独角兽企业重金招聘Python工程师标准>>> ...

    Zeu.js 详细介绍

    Zeu.js 是一个 JavaScript 库,其中包含一系列预构建的可视化组件,用于构建实时 TV 仪表板,监控 UI 和物联网Web界面。

    使用方法

    General

    使用 div 作为基础来创建组件,每个组件都有自己的建议大小。

    <div id="component-id" style="width: 200px; height: 100px;"></div>

    FPS

    使用 canvas 的组件的默认fps为60。

    zeu.Settings.fps = 60;

    使用案例:

    1、数字时钟:https://shzlw.github.io/zeu/examples/digital-clock.html

    2、消息队列动画:https://shzlw.github.io/zeu/examples/message-queue.html

    GitHub地址:https://github.com/shzlw/zeu

    转载于:https://my.oschina.net/u/2391658/blog/1865937

    展开全文
  • scrapy-monitor,实现爬虫可视化监控实时状态
  • 今天主要是来说一下怎么可视化来监控你的爬虫的状态。 相信大家在跑爬虫的过程中,也会好奇自己养的爬虫一分钟可以爬多少页面,多...可以实现对爬虫数量,增量,大小,大小增量的实时监控。 2. 环境 InfluxDb ,是目前
  • 文章目录【1x00】前言【2x00】思维导图【3x00】数据结构分析【4x00】主函数 main()【5x00】数据获取模块 data_get【5x01】初始函数 init()【5x02】中国总数据 china_total_data()【5x03】全球总数据 global_total_...


    这里是一段防爬虫文本,请读者忽略。
    本文原创首发于 CSDN,作者 TRHX。
    博客首页:https://itrhx.blog.csdn.net/
    本文链接:https://itrhx.blog.csdn.net/article/details/107140534
    未经授权,禁止转载!恶意转载,后果自负!尊重原创,远离剽窃!
    

    【1x00】前言

    本来两三个月之前就想搞个疫情数据实时数据展示的,由于各种不可抗拒因素一而再再而三的鸽了,最近终于抽空写了一个,数据是用 Python 爬取的百度疫情实时大数据报告,请求库用的 requests,解析用的 Xpath 语法,词云用的 wordcloud 库,数据可视化用 pyecharts 绘制的地图和折线图,数据储存在 Excel 表格里面,使用 openpyxl 对表格进行处理。

    本程序实现了累计确诊地图展示和每日数据变化折线图展示,其他更多数据的获取和展示均可在程序中进行拓展,可以将程序部署在服务器上,设置定时运行,即可实时展示数据,pyecharts 绘图模块也可以整合到 Web 框架(Django、Flask等)中使用。

    在获取数据时有全球境外两个概念,全球包含中国,境外不包含中国,后期绘制的四个图:中国累计确诊地图、全球累计确诊地图(包含中国)、中国每日数据折线图、境外每日数据折线图(不包含中国)。

    注意项:直接向该网页发送请求获取的响应中,没有每个国家的每日数据,该数据获取的地址是:https://voice.baidu.com/newpneumonia/get?target=trend&isCaseIn=1&stage=publish

    【2x00】思维导图

    01

    【3x00】数据结构分析

    通过查看百度的疫情数据页面,可以看到很多整齐的数据,猜测就是疫情相关的数据,保存该页面,对其进行格式化,很容易可以分析出所有的数据都在 <script type="application/json" id="captain-config"></script> 里面,其中 title 里面是一些 Unicode 编码,将其转为中文后更容易得到不同的分类数据。

    02

    由于数据繁多,可以将数据主体部分提取出来,删除一些重复项和其他杂项,留下数据大体位置并分析数据结构,便于后期的数据提取,经过处理后的数据大致结构如下:

    <script type="application/json" id="captain-config">
        {
            "component": [
                {
                    "mapLastUpdatedTime": "2020.07.05 16:13",        // 国内疫情数据最后更新时间
                    "caseList": [                                    // caseList 列表,每一个元素是一个字典
                        {
                            "confirmed": "1",                        // 每个字典包含中国每个省的每一项疫情数据
                            "died": "0",
                            "crued": "1",
                            "relativeTime": "1593792000",
                            "confirmedRelative": "0",
                            "diedRelative": "0",
                            "curedRelative": "0",
                            "curConfirm": "0",
                            "curConfirmRelative": "0",
                            "icuDisable": "1",
                            "area": "西藏",
                            "subList": [                            // subList 列表,每一个元素是一个字典
                                {
                                    "city": "拉萨",                 // 每个字典包含该省份对应的每个城市疫情数据
                                    "confirmed": "1",
                                    "died": "0",
                                    "crued": "1",
                                    "confirmedRelative": "0",
                                    "curConfirm": "0",
                                    "cityCode": "100"
                                }
                            ]
                        }
                    ],
                    "caseOutsideList": [                           // caseOutsideList 列表,每一个元素是一个字典
                        {
                            "confirmed": "241419",                 // 每个字典包含各国的每一项疫情数据
                            "died": "34854",
                            "crued": "191944",
                            "relativeTime": "1593792000",
                            "confirmedRelative": "223",
                            "curConfirm": "14621",
                            "icuDisable": "1",
                            "area": "意大利",
                            "subList": [                          // subList 列表,每一个元素是一个字典
                                {
                                    "city": "伦巴第",              // 每个字典包含每个国家对应的每个城市疫情数据
                                    "confirmed": "94318",
                                    "died": "16691",
                                    "crued": "68201",
                                    "curConfirm": "9426"
                                }
                            ]
                        }
                    ],
                    "summaryDataIn": {                           // summaryDataIn 国内总的疫情数据
                        "confirmed": "85307",
                        "died": "4648",
                        "cured": "80144",
                        "asymptomatic": "99",
                        "asymptomaticRelative": "7",
                        "unconfirmed": "7",
                        "relativeTime": "1593792000",
                        "confirmedRelative": "19",
                        "unconfirmedRelative": "1",
                        "curedRelative": "27",
                        "diedRelative": "0",
                        "icu": "6",
                        "icuRelative": "0",
                        "overseasInput": "1931",
                        "unOverseasInputCumulative": "83375",
                        "overseasInputRelative": "6",
                        "unOverseasInputNewAdd": "13",
                        "curConfirm": "515",
                        "curConfirmRelative": "-8",
                        "icuDisable": "1"
                    },
                    "summaryDataOut": {                           // summaryDataOut 国外总的疫情数据
                        "confirmed": "11302569",
                        "died": "528977",
                        "curConfirm": "4410601",
                        "cured": "6362991",
                        "confirmedRelative": "206165",
                        "curedRelative": "190018",
                        "diedRelative": "4876",
                        "curConfirmRelative": "11271",
                        "relativeTime": "1593792000"
                    },
                    "trend": {                                    // trend 字典,包含国内每日的疫情数据
                        "updateDate": [],                         // 日期
                        "list": [                                 // list 列表,每项数据及其对应的值
                            {
                                "name": "确诊",
                                "data": []
                            },
                            {
                                "name": "疑似",
                                "data": []
                            },
                            {
                                "name": "治愈",
                                "data": []
                            },
                            {
                                "name": "死亡",
                                "data": []
                            },
                            {
                                "name": "新增确诊",
                                "data": []
                            },
                            {
                                "name": "新增疑似",
                                "data": []
                            },
                            {
                                "name": "新增治愈",
                                "data": []
                            },
                            {
                                "name": "新增死亡",
                                "data": []
                            },
                            {
                                "name": "累计境外输入",
                                "data": []
                            },
                            {
                                "name": "新增境外输入",
                                "data": []
                            }
                        ]
                    },
                    "foreignLastUpdatedTime": "2020.07.05 16:13",       // 国外疫情数据最后更新时间
                    "globalList": [                                     // globalList 列表,每一个元素是一个字典
                        {
                            "area": "亚洲",                              // 按照不同洲进行分类
                            "subList": [                                // subList 列表,每个洲各个国家的疫情数据
                                {
                                    "died": "52",
                                    "confirmed": "6159",
                                    "crued": "4809",
                                    "curConfirm": "1298",
                                    "confirmedRelative": "0",
                                    "relativeTime": "1593792000",
                                    "country": "塔吉克斯坦"
                                }
                            ],
                            "died": "56556",                            // 每个洲总的疫情数据
                            "crued": "1625562",
                            "confirmed": "2447873",
                            "curConfirm": "765755",
                            "confirmedRelative": "60574"
                        },
                        {
                            "area": "其他",                             // 其他特殊区域疫情数据
                            "subList": [
                                {
                                    "died": "13",
                                    "confirmed": "712",
                                    "crued": "651",
                                    "curConfirm": "48",
                                    "confirmedRelative": "0",
                                    "relativeTime": "1593792000",
                                    "country": "钻石公主号邮轮"
                                }
                            ],
                            "died": "13",                              // 其他特殊区域疫情总的数据
                            "crued": "651",
                            "confirmed": "712",
                            "curConfirm": "48",
                            "confirmedRelative": "0"
                        },
                        {
                            "area": "热门",                            // 热门国家疫情数据
                            "subList": [
                                {
                                    "died": "5206",
                                    "confirmed": "204610",
                                    "crued": "179492",
                                    "curConfirm": "19912",
                                    "confirmedRelative": "1172",
                                    "relativeTime": "1593792000",
                                    "country": "土耳其"
                                }
                            ],
                            "died": "528967",                         // 热门国家疫情总的数据
                            "crued": "6362924",
                            "confirmed": "11302357",
                            "confirmedRelative": "216478",
                            "curConfirm": "4410466"
                        }],
                    "allForeignTrend": {                            // allForeignTrend 字典,包含国外每日的疫情数据
                            "updateDate": [],                       // 日期
                            "list": [                               // list 列表,每项数据及其对应的值
                                {
                                    "name": "累计确诊",
                                    "data": []
                                },
                                {
                                    "name": "治愈",
                                    "data": []
                                },
                                {
                                    "name": "死亡",
                                    "data": []
                                },
                                {
                                    "name": "现有确诊",
                                    "data": []
                                },
                                {
                                    "name": "新增确诊",
                                    "data": []
                                }
                            ]
                        },
                    "topAddCountry": [                    // 确诊增量最高的国家
                            {
                                "name": "美国",
                                "value": 53162
                            }
                        ],
                    "topOverseasInput": [                // 境外输入最多的省份
                        {
                            "name": "黑龙江",
                            "value": 386
                        }
                    ]
                }
            ]
        }
    </script>
    

    【4x00】主函数 main()

    分别将数据获取、词云图绘制、地图绘制写入三个文件:data_get()data_wordcloud()data_map(),然后使用一个主函数文件 main.py 来调用这三个文件里面的函数。

    import data_get
    import data_wordcloud
    import data_map
    
    data_dict = data_get.init()
    data_get.china_total_data(data_dict)
    data_get.global_total_data(data_dict)
    data_get.china_daily_data(data_dict)
    data_get.foreign_daily_data(data_dict)
    
    data_wordcloud.china_wordcloud()
    data_wordcloud.global_wordcloud()
    
    data_map.all_map()
    

    【5x00】数据获取模块 data_get

    【5x01】初始化函数 init()

    使用 xpath 语法 //script[@id="captain-config"]/text() 提取里面的值,利用 json.loads 方法将其转换为字典对象,以便后续的其他函数调用。

    def init():
        headers = {
            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.13 Safari/537.36'
        }
        url = 'https://voice.baidu.com/act/newpneumonia/newpneumonia/'
        response = requests.get(url=url, headers=headers)
        tree = etree.HTML(response.text)
        dict1 = tree.xpath('//script[@id="captain-config"]/text()')
        print(type(dict1[0]))
        dict2 = json.loads(dict1[0])
        return dict2
    

    【5x02】中国总数据 china_total_data()

    def china_total_data(data):
    
        """
        1、中国省/直辖市/自治区/行政区疫情数据
        省/直辖市/自治区/行政区:area
        现有确诊:    curConfirm
        累计确诊:    confirmed
        累计治愈:    crued
        累计死亡:    died
        现有确诊增量: curConfirmRelative
        累计确诊增量: confirmedRelative
        累计治愈增量: curedRelative
        累计死亡增量: diedRelative
        """
    
        wb = openpyxl.Workbook()            # 创建工作簿
        ws_china = wb.active                # 获取工作表
        ws_china.title = "中国省份疫情数据"   # 命名工作表
        ws_china.append(['省/直辖市/自治区/行政区', '现有确诊', '累计确诊', '累计治愈',
                         '累计死亡', '现有确诊增量', '累计确诊增量',
                         '累计治愈增量', '累计死亡增量'])
        china = data['component'][0]['caseList']
        for province in china:
            ws_china.append([province['area'],
                            province['curConfirm'],
                            province['confirmed'],
                            province['crued'],
                            province['died'],
                            province['curConfirmRelative'],
                            province['confirmedRelative'],
                            province['curedRelative'],
                            province['diedRelative']])
    
        """
        2、中国城市疫情数据
        城市:city
        现有确诊:curConfirm
        累计确诊:confirmed
        累计治愈:crued
        累计死亡:died
        累计确诊增量:confirmedRelative
        """
    
        ws_city = wb.create_sheet('中国城市疫情数据')
        ws_city.append(['城市', '现有确诊', '累计确诊',
                        '累计治愈', '累计死亡', '累计确诊增量'])
        for province in china:
            for city in province['subList']:
                # 某些城市没有 curConfirm 数据,则将其设置为 0,crued 和 died 为空时,替换成 0
                if 'curConfirm' not in city:
                    city['curConfirm'] = '0'
                if city['crued'] == '':
                    city['crued'] = '0'
                if city['died'] == '':
                    city['died'] = '0'
                ws_city.append([city['city'], '0', city['confirmed'],
                               city['crued'], city['died'], city['confirmedRelative']])
    
        """
        3、中国疫情数据更新时间:mapLastUpdatedTime
        """
    
        time_domestic = data['component'][0]['mapLastUpdatedTime']
        ws_time = wb.create_sheet('中国疫情数据更新时间')
        ws_time.column_dimensions['A'].width = 22  # 调整列宽
        ws_time.append(['中国疫情数据更新时间'])
        ws_time.append([time_domestic])
    
        wb.save('COVID-19-China.xlsx')
        print('中国疫情数据已保存至 COVID-19-China.xlsx!')
    

    【5x03】全球总数据 global_total_data()

    全球总数据在提取完成后,进行地图绘制时发现并没有中国的数据,因此在写入全球数据时注意要单独将中国的数据插入 Excel 中。

    def global_total_data(data):
    
        """
        1、全球各国疫情数据
        国家:country
        现有确诊:curConfirm
        累计确诊:confirmed
        累计治愈:crued
        累计死亡:died
        累计确诊增量:confirmedRelative
        """
    
        wb = openpyxl.Workbook()
        ws_global = wb.active
        ws_global.title = "全球各国疫情数据"
    
        # 按照国家保存数据
        countries = data['component'][0]['caseOutsideList']
        ws_global.append(['国家', '现有确诊', '累计确诊', '累计治愈', '累计死亡', '累计确诊增量'])
        for country in countries:
            ws_global.append([country['area'],
                              country['curConfirm'],
                              country['confirmed'],
                              country['crued'],
                              country['died'],
                              country['confirmedRelative']])
    
        # 按照洲保存数据
        continent = data['component'][0]['globalList']
        for area in continent:
            ws_foreign = wb.create_sheet(area['area'] + '疫情数据')
            ws_foreign.append(['国家', '现有确诊', '累计确诊', '累计治愈', '累计死亡', '累计确诊增量'])
            for country in area['subList']:
                ws_foreign.append([country['country'],
                                   country['curConfirm'],
                                   country['confirmed'],
                                   country['crued'],
                                   country['died'],
                                   country['confirmedRelative']])
    
        # 在“全球各国疫情数据”和“亚洲疫情数据”两张表中写入中国疫情数据
        ws1, ws2 = wb['全球各国疫情数据'], wb['亚洲疫情数据']
        original_data = data['component'][0]['summaryDataIn']
        add_china_data = ['中国',
                          original_data['curConfirm'],
                          original_data['confirmed'],
                          original_data['cured'],
                          original_data['died'],
                          original_data['confirmedRelative']]
        ws1.append(add_china_data)
        ws2.append(add_china_data)
    
        """
        2、全球疫情数据更新时间:foreignLastUpdatedTime
        """
    
        time_foreign = data['component'][0]['foreignLastUpdatedTime']
        ws_time = wb.create_sheet('全球疫情数据更新时间')
        ws_time.column_dimensions['A'].width = 22  # 调整列宽
        ws_time.append(['全球疫情数据更新时间'])
        ws_time.append([time_foreign])
    
        wb.save('COVID-19-Global.xlsx')
        print('全球疫情数据已保存至 COVID-19-Global.xlsx!')
    

    【5x04】中国每日数据 china_daily_data()

    def china_daily_data(data):
    
        """
        i_dict = data['component'][0]['trend']
        i_dict['updateDate']:日期
        i_dict['list'][0]:确诊
        i_dict['list'][1]:疑似
        i_dict['list'][2]:治愈
        i_dict['list'][3]:死亡
        i_dict['list'][4]:新增确诊
        i_dict['list'][5]:新增疑似
        i_dict['list'][6]:新增治愈
        i_dict['list'][7]:新增死亡
        i_dict['list'][8]:累计境外输入
        i_dict['list'][9]:新增境外输入
        """
    
        ccd_dict = data['component'][0]['trend']
        update_date = ccd_dict['updateDate']              # 日期
        china_confirmed = ccd_dict['list'][0]['data']     # 每日累计确诊数据
        china_crued = ccd_dict['list'][2]['data']         # 每日累计治愈数据
        china_died = ccd_dict['list'][3]['data']          # 每日累计死亡数据
        wb = openpyxl.load_workbook('COVID-19-China.xlsx')
    
        # 写入每日累计确诊数据
        ws_china_confirmed = wb.create_sheet('中国每日累计确诊数据')
        ws_china_confirmed.append(['日期', '数据'])
        for data in zip(update_date, china_confirmed):
            ws_china_confirmed.append(data)
    
        # 写入每日累计治愈数据
        ws_china_crued = wb.create_sheet('中国每日累计治愈数据')
        ws_china_crued.append(['日期', '数据'])
        for data in zip(update_date, china_crued):
            ws_china_crued.append(data)
    
        # 写入每日累计死亡数据
        ws_china_died = wb.create_sheet('中国每日累计死亡数据')
        ws_china_died.append(['日期', '数据'])
        for data in zip(update_date, china_died):
            ws_china_died.append(data)
    
        wb.save('COVID-19-China.xlsx')
        print('中国每日累计确诊/治愈/死亡数据已保存至 COVID-19-China.xlsx!')
    

    【5x05】境外每日数据 foreign_daily_data()

    def foreign_daily_data(data):
    
        """
        te_dict = data['component'][0]['allForeignTrend']
        te_dict['updateDate']:日期
        te_dict['list'][0]:累计确诊
        te_dict['list'][1]:治愈
        te_dict['list'][2]:死亡
        te_dict['list'][3]:现有确诊
        te_dict['list'][4]:新增确诊
        """
    
        te_dict = data['component'][0]['allForeignTrend']
        update_date = te_dict['updateDate']                # 日期
        foreign_confirmed = te_dict['list'][0]['data']     # 每日累计确诊数据
        foreign_crued = te_dict['list'][1]['data']         # 每日累计治愈数据
        foreign_died = te_dict['list'][2]['data']          # 每日累计死亡数据
        wb = openpyxl.load_workbook('COVID-19-Global.xlsx')
    
        # 写入每日累计确诊数据
        ws_foreign_confirmed = wb.create_sheet('境外每日累计确诊数据')
        ws_foreign_confirmed.append(['日期', '数据'])
        for data in zip(update_date, foreign_confirmed):
            ws_foreign_confirmed.append(data)
    
        # 写入累计治愈数据
        ws_foreign_crued = wb.create_sheet('境外每日累计治愈数据')
        ws_foreign_crued.append(['日期', '数据'])
        for data in zip(update_date, foreign_crued):
            ws_foreign_crued.append(data)
    
        # 写入累计死亡数据
        ws_foreign_died = wb.create_sheet('境外每日累计死亡数据')
        ws_foreign_died.append(['日期', '数据'])
        for data in zip(update_date, foreign_died):
            ws_foreign_died.append(data)
    
        wb.save('COVID-19-Global.xlsx')
        print('境外每日累计确诊/治愈/死亡数据已保存至 COVID-19-Global.xlsx!')
    

    【6x00】词云图绘制模块 data_wordcloud

    【6x01】中国累计确诊词云图 foreign_daily_data()

    def china_wordcloud():
        wb = openpyxl.load_workbook('COVID-19-China.xlsx')  # 获取已有的xlsx文件
        ws_china = wb['中国省份疫情数据']                     # 获取中国省份疫情数据表
        ws_china.delete_rows(1)                             # 删除第一行
        china_dict = {}                                     # 将省份及其累计确诊按照键值对形式储存在字典中
        for data in ws_china.values:
            china_dict[data[0]] = int(data[2])
        word_cloud = wordcloud.WordCloud(font_path='C:/Windows/Fonts/simsun.ttc',
                                         background_color='#CDC9C9',
                                         min_font_size=15,
                                         width=900, height=500)
        word_cloud.generate_from_frequencies(china_dict)
        word_cloud.to_file('WordCloud-China.png')
        print('中国省份疫情词云图绘制完毕!')
    

    【6x02】全球累计确诊词云图 foreign_daily_data()

    def global_wordcloud():
        wb = openpyxl.load_workbook('COVID-19-Global.xlsx')
        ws_global = wb['全球各国疫情数据']
        ws_global.delete_rows(1)
        global_dict = {}
        for data in ws_global.values:
            global_dict[data[0]] = int(data[2])
        word_cloud = wordcloud.WordCloud(font_path='C:/Windows/Fonts/simsun.ttc',
                                         background_color='#CDC9C9',
                                         width=900, height=500)
        word_cloud.generate_from_frequencies(global_dict)
        word_cloud.to_file('WordCloud-Global.png')
        print('全球各国疫情词云图绘制完毕!')
    

    这里是一段防爬虫文本,请读者忽略。
    本文原创首发于 CSDN,作者 TRHX。
    博客首页:https://itrhx.blog.csdn.net/
    本文链接:https://itrhx.blog.csdn.net/article/details/107140534
    未经授权,禁止转载!恶意转载,后果自负!尊重原创,远离剽窃!
    

    【7x00】地图绘制模块 data_map

    【7x01】中国累计确诊地图 china_total_map()

    def china_total_map():
        wb = openpyxl.load_workbook('COVID-19-China.xlsx')  # 获取已有的xlsx文件
        ws_time = wb['中国疫情数据更新时间']                   # 获取文件中中国疫情数据更新时间表
        ws_data = wb['中国省份疫情数据']                      # 获取文件中中国省份疫情数据表
        ws_data.delete_rows(1)                              # 删除第一行
        province = []                                       # 省份
        curconfirm = []                                     # 累计确诊
        for data in ws_data.values:
            province.append(data[0])
            curconfirm.append(data[2])
        time_china = ws_time['A2'].value                    # 更新时间
    
        # 设置分级颜色
        pieces = [
            {'max': 0, 'min': 0, 'label': '0', 'color': '#FFFFFF'},
            {'max': 9, 'min': 1, 'label': '1-9', 'color': '#FFE5DB'},
            {'max': 99, 'min': 10, 'label': '10-99', 'color': '#FF9985'},
            {'max': 999, 'min': 100, 'label': '100-999', 'color': '#F57567'},
            {'max': 9999, 'min': 1000, 'label': '1000-9999', 'color': '#E64546'},
            {'max': 99999, 'min': 10000, 'label': '≧10000', 'color': '#B80909'}
        ]
    
        # 绘制地图
        ct_map = (
            Map()
            .add(series_name='累计确诊人数', data_pair=[list(z) for z in zip(province, curconfirm)], maptype="china")
            .set_global_opts(
                title_opts=opts.TitleOpts(title="中国疫情数据(累计确诊)",
                                          subtitle='数据更新至:' + time_china + '\n\n来源:百度疫情实时大数据报告'),
                visualmap_opts=opts.VisualMapOpts(max_=300, is_piecewise=True, pieces=pieces)
            )
        )
        return ct_map
    

    【7x02】全球累计确诊地图 global_total_map()

    def global_total_map():
        wb = openpyxl.load_workbook('COVID-19-Global.xlsx')
        ws_time = wb['全球疫情数据更新时间']
        ws_data = wb['全球各国疫情数据']
        ws_data.delete_rows(1)
        country = []                        # 国家
        curconfirm = []                     # 累计确诊
        for data in ws_data.values:
            country.append(data[0])
            curconfirm.append(data[2])
        time_global = ws_time['A2'].value   # 更新时间
    
        # 国家名称中英文映射表
        name_map = {
              "Somalia": "索马里",
              "Liechtenstein": "列支敦士登",
              "Morocco": "摩洛哥",
              "W. Sahara": "西撒哈拉",
              "Serbia": "塞尔维亚",
              "Afghanistan": "阿富汗",
              "Angola": "安哥拉",
              "Albania": "阿尔巴尼亚",
              "Andorra": "安道尔共和国",
              "United Arab Emirates": "阿拉伯联合酋长国",
              "Argentina": "阿根廷",
              "Armenia": "亚美尼亚",
              "Australia": "澳大利亚",
              "Austria": "奥地利",
              "Azerbaijan": "阿塞拜疆",
              "Burundi": "布隆迪",
              "Belgium": "比利时",
              "Benin": "贝宁",
              "Burkina Faso": "布基纳法索",
              "Bangladesh": "孟加拉国",
              "Bulgaria": "保加利亚",
              "Bahrain": "巴林",
              "Bahamas": "巴哈马",
              "Bosnia and Herz.": "波斯尼亚和黑塞哥维那",
              "Belarus": "白俄罗斯",
              "Belize": "伯利兹",
              "Bermuda": "百慕大",
              "Bolivia": "玻利维亚",
              "Brazil": "巴西",
              "Barbados": "巴巴多斯",
              "Brunei": "文莱",
              "Bhutan": "不丹",
              "Botswana": "博茨瓦纳",
              "Central African Rep.": "中非共和国",
              "Canada": "加拿大",
              "Switzerland": "瑞士",
              "Chile": "智利",
              "China": "中国",
              "Côte d'Ivoire": "科特迪瓦",
              "Cameroon": "喀麦隆",
              "Dem. Rep. Congo": "刚果(布)",
              "Congo": "刚果(金)",
              "Colombia": "哥伦比亚",
              "Cape Verde": "佛得角",
              "Costa Rica": "哥斯达黎加",
              "Cuba": "古巴",
              "N. Cyprus": "北塞浦路斯",
              "Cyprus": "塞浦路斯",
              "Czech Rep.": "捷克",
              "Germany": "德国",
              "Djibouti": "吉布提",
              "Denmark": "丹麦",
              "Dominican Rep.": "多米尼加",
              "Algeria": "阿尔及利亚",
              "Ecuador": "厄瓜多尔",
              "Egypt": "埃及",
              "Eritrea": "厄立特里亚",
              "Spain": "西班牙",
              "Estonia": "爱沙尼亚",
              "Ethiopia": "埃塞俄比亚",
              "Finland": "芬兰",
              "Fiji": "斐济",
              "France": "法国",
              "Gabon": "加蓬",
              "United Kingdom": "英国",
              "Georgia": "格鲁吉亚",
              "Ghana": "加纳",
              "Guinea": "几内亚",
              "Gambia": "冈比亚",
              "Guinea-Bissau": "几内亚比绍",
              "Eq. Guinea": "赤道几内亚",
              "Greece": "希腊",
              "Grenada": "格林纳达",
              "Greenland": "格陵兰岛",
              "Guatemala": "危地马拉",
              "Guam": "关岛",
              "Guyana": "圭亚那合作共和国",
              "Honduras": "洪都拉斯",
              "Croatia": "克罗地亚",
              "Haiti": "海地",
              "Hungary": "匈牙利",
              "Indonesia": "印度尼西亚",
              "India": "印度",
              "Br. Indian Ocean Ter.": "英属印度洋领土",
              "Ireland": "爱尔兰",
              "Iran": "伊朗",
              "Iraq": "伊拉克",
              "Iceland": "冰岛",
              "Israel": "以色列",
              "Italy": "意大利",
              "Jamaica": "牙买加",
              "Jordan": "约旦",
              "Japan": "日本",
              "Siachen Glacier": "锡亚琴冰川",
              "Kazakhstan": "哈萨克斯坦",
              "Kenya": "肯尼亚",
              "Kyrgyzstan": "吉尔吉斯斯坦",
              "Cambodia": "柬埔寨",
              "Korea": "韩国",
              "Kuwait": "科威特",
              "Lao PDR": "老挝",
              "Lebanon": "黎巴嫩",
              "Liberia": "利比里亚",
              "Libya": "利比亚",
              "Sri Lanka": "斯里兰卡",
              "Lesotho": "莱索托",
              "Lithuania": "立陶宛",
              "Luxembourg": "卢森堡",
              "Latvia": "拉脱维亚",
              "Moldova": "摩尔多瓦",
              "Madagascar": "马达加斯加",
              "Mexico": "墨西哥",
              "Macedonia": "马其顿",
              "Mali": "马里",
              "Malta": "马耳他",
              "Myanmar": "缅甸",
              "Montenegro": "黑山",
              "Mongolia": "蒙古国",
              "Mozambique": "莫桑比克",
              "Mauritania": "毛里塔尼亚",
              "Mauritius": "毛里求斯",
              "Malawi": "马拉维",
              "Malaysia": "马来西亚",
              "Namibia": "纳米比亚",
              "New Caledonia": "新喀里多尼亚",
              "Niger": "尼日尔",
              "Nigeria": "尼日利亚",
              "Nicaragua": "尼加拉瓜",
              "Netherlands": "荷兰",
              "Norway": "挪威",
              "Nepal": "尼泊尔",
              "New Zealand": "新西兰",
              "Oman": "阿曼",
              "Pakistan": "巴基斯坦",
              "Panama": "巴拿马",
              "Peru": "秘鲁",
              "Philippines": "菲律宾",
              "Papua New Guinea": "巴布亚新几内亚",
              "Poland": "波兰",
              "Puerto Rico": "波多黎各",
              "Dem. Rep. Korea": "朝鲜",
              "Portugal": "葡萄牙",
              "Paraguay": "巴拉圭",
              "Palestine": "巴勒斯坦",
              "Qatar": "卡塔尔",
              "Romania": "罗马尼亚",
              "Russia": "俄罗斯",
              "Rwanda": "卢旺达",
              "Saudi Arabia": "沙特阿拉伯",
              "Sudan": "苏丹",
              "S. Sudan": "南苏丹",
              "Senegal": "塞内加尔",
              "Singapore": "新加坡",
              "Solomon Is.": "所罗门群岛",
              "Sierra Leone": "塞拉利昂",
              "El Salvador": "萨尔瓦多",
              "Suriname": "苏里南",
              "Slovakia": "斯洛伐克",
              "Slovenia": "斯洛文尼亚",
              "Sweden": "瑞典",
              "Swaziland": "斯威士兰",
              "Seychelles": "塞舌尔",
              "Syria": "叙利亚",
              "Chad": "乍得",
              "Togo": "多哥",
              "Thailand": "泰国",
              "Tajikistan": "塔吉克斯坦",
              "Turkmenistan": "土库曼斯坦",
              "Timor-Leste": "东帝汶",
              "Tonga": "汤加",
              "Trinidad and Tobago": "特立尼达和多巴哥",
              "Tunisia": "突尼斯",
              "Turkey": "土耳其",
              "Tanzania": "坦桑尼亚",
              "Uganda": "乌干达",
              "Ukraine": "乌克兰",
              "Uruguay": "乌拉圭",
              "United States": "美国",
              "Uzbekistan": "乌兹别克斯坦",
              "Venezuela": "委内瑞拉",
              "Vietnam": "越南",
              "Vanuatu": "瓦努阿图",
              "Yemen": "也门",
              "South Africa": "南非",
              "Zambia": "赞比亚",
              "Zimbabwe": "津巴布韦",
              "Aland": "奥兰群岛",
              "American Samoa": "美属萨摩亚",
              "Fr. S. Antarctic Lands": "南极洲",
              "Antigua and Barb.": "安提瓜和巴布达",
              "Comoros": "科摩罗",
              "Curaçao": "库拉索岛",
              "Cayman Is.": "开曼群岛",
              "Dominica": "多米尼加",
              "Falkland Is.": "福克兰群岛马尔维纳斯",
              "Faeroe Is.": "法罗群岛",
              "Micronesia": "密克罗尼西亚",
              "Heard I. and McDonald Is.": "赫德岛和麦克唐纳群岛",
              "Isle of Man": "曼岛",
              "Jersey": "泽西岛",
              "Kiribati": "基里巴斯",
              "Saint Lucia": "圣卢西亚",
              "N. Mariana Is.": "北马里亚纳群岛",
              "Montserrat": "蒙特塞拉特",
              "Niue": "纽埃",
              "Palau": "帕劳",
              "Fr. Polynesia": "法属波利尼西亚",
              "S. Geo. and S. Sandw. Is.": "南乔治亚岛和南桑威奇群岛",
              "Saint Helena": "圣赫勒拿",
              "St. Pierre and Miquelon": "圣皮埃尔和密克隆群岛",
              "São Tomé and Principe": "圣多美和普林西比",
              "Turks and Caicos Is.": "特克斯和凯科斯群岛",
              "St. Vin. and Gren.": "圣文森特和格林纳丁斯",
              "U.S. Virgin Is.": "美属维尔京群岛",
              "Samoa": "萨摩亚"
            }
    
        pieces = [
            {'max': 0, 'min': 0, 'label': '0', 'color': '#FFFFFF'},
            {'max': 49, 'min': 1, 'label': '1-49', 'color': '#FFE5DB'},
            {'max': 99, 'min': 50, 'label': '50-99', 'color': '#FFC4B3'},
            {'max': 999, 'min': 100, 'label': '100-999', 'color': '#FF9985'},
            {'max': 9999, 'min': 1000, 'label': '1000-9999', 'color': '#F57567'},
            {'max': 99999, 'min': 10000, 'label': '10000-99999', 'color': '#E64546'},
            {'max': 999999, 'min': 100000, 'label': '100000-999999', 'color': '#B80909'},
            {'max': 9999999, 'min': 1000000, 'label': '≧1000000', 'color': '#8A0808'}
        ]
    
        gt_map = (
            Map()
            .add(series_name='累计确诊人数', data_pair=[list(z) for z in zip(country, curconfirm)], maptype="world", name_map=name_map, is_map_symbol_show=False)
            .set_series_opts(label_opts=opts.LabelOpts(is_show=False))
            .set_global_opts(
                title_opts=opts.TitleOpts(title="全球疫情数据(累计确诊)",
                                          subtitle='数据更新至:' + time_global + '\n\n来源:百度疫情实时大数据报告'),
                visualmap_opts=opts.VisualMapOpts(max_=300, is_piecewise=True, pieces=pieces),
            )
        )
        return gt_map
    

    【7x03】中国每日数据折线图 china_daily_map()

    def china_daily_map():
        wb = openpyxl.load_workbook('COVID-19-China.xlsx')
        ws_china_confirmed = wb['中国每日累计确诊数据']
        ws_china_crued = wb['中国每日累计治愈数据']
        ws_china_died = wb['中国每日累计死亡数据']
    
        ws_china_confirmed.delete_rows(1)
        ws_china_crued.delete_rows(1)
        ws_china_died.delete_rows(1)
    
        x_date = []               # 日期
        y_china_confirmed = []    # 每日累计确诊
        y_china_crued = []        # 每日累计治愈
        y_china_died = []         # 每日累计死亡
    
        for china_confirmed in ws_china_confirmed.values:
            y_china_confirmed.append(china_confirmed[1])
        for china_crued in ws_china_crued.values:
            x_date.append(china_crued[0])
            y_china_crued.append(china_crued[1])
        for china_died in ws_china_died.values:
            y_china_died.append(china_died[1])
    
        fi_map = (
            Line(init_opts=opts.InitOpts(height='420px'))
                .add_xaxis(xaxis_data=x_date)
                .add_yaxis(
                series_name="中国累计确诊数据",
                y_axis=y_china_confirmed,
                label_opts=opts.LabelOpts(is_show=False),
            )
                .add_yaxis(
                series_name="中国累计治愈趋势",
                y_axis=y_china_crued,
                label_opts=opts.LabelOpts(is_show=False),
            )
                .add_yaxis(
                series_name="中国累计死亡趋势",
                y_axis=y_china_died,
                label_opts=opts.LabelOpts(is_show=False),
            )
                .set_global_opts(
                title_opts=opts.TitleOpts(title="中国每日累计确诊/治愈/死亡趋势"),
                legend_opts=opts.LegendOpts(pos_bottom="bottom", orient='horizontal'),
                tooltip_opts=opts.TooltipOpts(trigger="axis"),
                yaxis_opts=opts.AxisOpts(
                    type_="value",
                    axistick_opts=opts.AxisTickOpts(is_show=True),
                    splitline_opts=opts.SplitLineOpts(is_show=True),
                ),
                xaxis_opts=opts.AxisOpts(type_="category", boundary_gap=False),
            )
        )
        return fi_map
    

    【7x04】境外每日数据折线图 foreign_daily_map()

    def foreign_daily_map():
        wb = openpyxl.load_workbook('COVID-19-Global.xlsx')
        ws_foreign_confirmed = wb['境外每日累计确诊数据']
        ws_foreign_crued = wb['境外每日累计治愈数据']
        ws_foreign_died = wb['境外每日累计死亡数据']
    
        ws_foreign_confirmed.delete_rows(1)
        ws_foreign_crued.delete_rows(1)
        ws_foreign_died.delete_rows(1)
    
        x_date = []                # 日期
        y_foreign_confirmed = []   # 累计确诊
        y_foreign_crued = []       # 累计治愈
        y_foreign_died = []        # 累计死亡
    
        for foreign_confirmed in ws_foreign_confirmed.values:
            y_foreign_confirmed.append(foreign_confirmed[1])
        for foreign_crued in ws_foreign_crued.values:
            x_date.append(foreign_crued[0])
            y_foreign_crued.append(foreign_crued[1])
        for foreign_died in ws_foreign_died.values:
            y_foreign_died.append(foreign_died[1])
    
        fte_map = (
            Line(init_opts=opts.InitOpts(height='420px'))
                .add_xaxis(xaxis_data=x_date)
                .add_yaxis(
                series_name="境外累计确诊趋势",
                y_axis=y_foreign_confirmed,
                label_opts=opts.LabelOpts(is_show=False),
            )
                .add_yaxis(
                series_name="境外累计治愈趋势",
                y_axis=y_foreign_crued,
                label_opts=opts.LabelOpts(is_show=False),
            )
                .add_yaxis(
                series_name="境外累计死亡趋势",
                y_axis=y_foreign_died,
                label_opts=opts.LabelOpts(is_show=False),
            )
                .set_global_opts(
                title_opts=opts.TitleOpts(title="境外每日累计确诊/治愈/死亡趋势"),
                legend_opts=opts.LegendOpts(pos_bottom="bottom", orient='horizontal'),
                tooltip_opts=opts.TooltipOpts(trigger="axis"),
                yaxis_opts=opts.AxisOpts(
                    type_="value",
                    axistick_opts=opts.AxisTickOpts(is_show=True),
                    splitline_opts=opts.SplitLineOpts(is_show=True),
                ),
                xaxis_opts=opts.AxisOpts(type_="category", boundary_gap=False),
            )
        )
        return fte_map
    

    【8x00】结果截图

    【8x01】数据储存 Excel

    03

    04

    【8x02】词云图

    05

    06

    【8x03】地图 + 折线图

    07

    【9x00】完整代码

    预览地址:http://cov.itrhx.com/

    完整代码地址(点亮 star 有 buff 加成):https://github.com/TRHX/Python3-Spider-Practice/tree/master/COVID-19

    其他爬虫实战代码合集(持续更新):https://github.com/TRHX/Python3-Spider-Practice

    爬虫实战专栏(持续更新):https://itrhx.blog.csdn.net/article/category/9351278


    这里是一段防爬虫文本,请读者忽略。
    本文原创首发于 CSDN,作者 TRHX。
    博客首页:https://itrhx.blog.csdn.net/
    本文链接:https://itrhx.blog.csdn.net/article/details/107140534
    未经授权,禁止转载!恶意转载,后果自负!尊重原创,远离剽窃!
    

    展开全文
  • Bus Time是一个基于Python / Django的Web应用程序,它使用GPS坐标显示当前公共交通工具的行驶位置。 此源代码可在。 图形和功能的某些部分可能未在开放许可下发布。 特性/功能 高度优化的组件。 请注意所有内容...
  • preface 流式数据的监控,以下主要是从算法的呈现出发,提供一种python的实现思路其中: 1.python是2.X版本 2.提供两种实现思路,一是基于matplotlib的animation,一是基于matplotlib的ion全篇目录为:一、一点...

    preface 
    流式数据的监控,以下主要是从算法的呈现出发,提供一种python的实现思路


    其中: 
    1.python是2.X版本 
    2.提供两种实现思路,一是基于matplotlib的animation,一是基于matplotlib的ion

    全篇目录为:

    一、一点构思
    二、matplotlib animation实现思路
      (一)、骨架与实时更新
      (二)、animation的优缺点
    三、matplotlib ion实现思路
      (一)、实时更新
      (二)、ion的优缺点
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    话不多说,先了解大概的效果,如下:

    最终呈现

    一、一点构思

           在做此流数据输出可视化前,一直在捣鼓nupic框架,其内部HTM算法主要是一种智能的异常检测算法,是目前AI框架中垂直领域下的一股清流,但由于其实现的例子对应的流数据展示并非我想要的,故此借鉴后自己重新写了一个,主要是达到三个目的,一是展示真实数据的波动,二是展示各波动的异常得分,三是罗列异常的点。 
           上述的输出结构并非重点,重点是其实时更新的机制,了解后即可自行定义。另,js对于这种流数据展示应该不难,所以本文主要立足的是算法的呈现角度以及python的实现。

    二、matplotlib animation实现思路

    http://matplotlib.org/api/animation_api.html 链接是matplotlib animation的官方api文档

    (一)、骨架与实时更新

           animation翻译过来就是动画,其动画展示核心主要有三个:1是动画的骨架先搭好,就是图像的边边框框这些,2是更新的过程,即传入实时数据时图形的变化方法,3是FuncAnimation方法结尾。

           下面以一个小例子做进一步说明: 
           1.对于动画的骨架:

    # initial the figure.
    x = []
    y = []
    fig = plt.figure(figsize=(18, 8), facecolor="white")
    ax1 = fig.add_subplot(111)
    p1, = ax1.plot(x, y, linestyle="dashed", color="red")
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    以上分别对应初始化空数据,初始化图形大小和背景颜色,插入子图(三个数字分别表示几行几列第几个位置),初始化图形(数据为空)。

    import numpy as np
    x = np.arange(0, 1000, 1)
    y = np.random.normal(100, 10, 1000)
    • 1
    • 2
    • 3

    随机生成一些作图数据,下面定义update过程。

           2.对于更新过程:

    def update(i):
        x.append(xs[i])
        y.append(ys[i])
        ax1.set_xlim(min(x),max(x)+1)
        ax1.set_ylim(min(y),max(y)+1)
        p1.set_data(x,y)
        ax1.figure.canvas.draw()
        return p1
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    上述定义更新函数,参数i为每轮迭代从FuncAnimation方法frames参数传进来的数值,frames参数的指定下文会进一步说,x/y通过相应更新之后,对图形的x/y轴大小做相应的重设,再把数据通过set_data传进图形,注意ax1和p1的区别,最后再把上述的变化通过draw()方法绘制到界面上,返回p1给FuncAnimation方法。

           3.对于FuncAnimation方法:

    ani = FuncAnimation(fig=fig,func=update,frames=len(xs),interval=1)
    plt.show()
    • 1
    • 2

    FuncAnimation方法主要是与update函数做交互,将frames参数对应的数据逐条传进update函数,再由update函数返回的图形覆盖FuncAnimation原先的图形,fig参数即为一开始对应的参数,interval为每次更新的时间间隔,还有其他一些参数如blit=True控制图形精细,当界面较多子图时,为True可以使得看起来不会太卡,关键是frames参数,下面是官方给出的注释:

    frames

    可为迭代数,可为函数,也可为空,上面我指定为数组的长度,其迭代则从0开始到最后该数值停止。

           该例子最终呈现的效果如下:

    example2

    了解大概的实现,细节就不在这里多说了。

    (二)、animation的优缺点

           animation的绘制的结果相比于下文的ion会更加的细腻,主要体现在FuncAnimation方法的一些参数的控制上。但是缺点也是明显,就是必须先有指定的数据或者指定的数据大小,显然这样对于预先无法知道数据的情况没法处理。所以换一种思路,在matplotlib ion打开的模式下,每次往模板插入数据都会进行相应的更新,具体看第二部分。

    三、matplotlib ion实现思路

    (一)、实时更新

           matplotlib ion的实现也主要是三个核心,1是打开ion,2是实时更新机制,3是呈现在界面上。

           1.对于打开ion: 
    ion全称是 interactive on(交互打开),其意为打开一个图形的交互接口,之后每次绘图都在之前打开的面板上操作,举个例子:

    import matplotlib.pyplot as plt
    plt.ion()
    fig = plt.figure()
    ax1 = fig.add_subplot(111)
    line, = ax1.plot(t, v, linestyle="-", color="r")
    • 1
    • 2
    • 3
    • 4
    • 5

    打开交互接口,初始化图形。

           2.对于实时更新机制:

    import numpy as np
    ys = np.random.normal(100, 10, 1000)
    
    def p(a, b):
        t.append(a)
        v.append(b)
        ax1.set_xlim(min(t), max(t) + 1)
        ax1.set_ylim(min(v), max(v) + 1)
        line.set_data(t, v)
        plt.pause(0.001)
        ax1.figure.canvas.draw()
    
    for i in xrange(len(ys)):
        p(i, ys[i])
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    随机生成一组数据,定义作图函数p(包含pause表示暂定时延,最好有,防止界面卡死),传入数据实时更新。

           3.对于界面最终呈现

    plt.ioff()
    plt.show()
    • 1
    • 2

    ioff是关闭交互模式,就像open打开文件产生的句柄,最好也有个close关掉。

           最终效果如下: 
    example3

    (二)、ion的优缺点

           animation可以在细节上控制比ion更加细腻,这也是ion没有的一点,但是单就无需预先指定数据这一点,ion也无疑是能把流数据做得更加好。

    四、最后

           贴一下两种方法在最开始那种图的做法,ion我定义成类,这样每次调用只需穿入参数就可以。

    animation版本

    # _*_ coding:utf-8 _*_
    
    import os
    import csv
    import datetime
    import matplotlib.pyplot as plt
    from matplotlib.animation import FuncAnimation
    from matplotlib.dates import DateFormatter
    import matplotlib.ticker as ticker
    
    # read the file
    filePath = os.path.join(os.getcwd(), "data/anomalyDetect_output.csv")
    file = open(filePath, "r")
    allData = csv.reader(file)
    # skip the first three columns
    allData.next()
    allData.next()
    allData.next()
    # cache the data
    data = [line for line in allData]
    # for i in data: print i
    
    # take out the target value
    timestamp = [line[0] for line in data]
    value = [line[1:] for line in data]
    
    
    # format the time style 2016-12-01 00:00:00
    def timestampFormat(t):
        result = datetime.datetime.strptime(t, "%Y-%m-%d %H:%M:%S")
        return result
    
    
    # take out the data
    timestamp = map(timestampFormat, timestamp)
    value_a = [float(x[0]) for x in value]
    predict_a = [float(x[1]) for x in value]
    anomalyScore_a = [float(x[2]) for x in value]
    
    # initial the size of the figure
    fig = plt.figure(figsize=(18, 8), facecolor="white")
    fig.subplots_adjust(left=0.06, right=0.70)
    ax1 = fig.add_subplot(2, 1, 1)
    ax2 = fig.add_subplot(2, 1, 2)
    ax3 = fig.add_axes([0.8, 0.1, 0.2, 0.8], frameon=False)
    
    # initial plot
    p1, = ax1.plot_date([], [], fmt="-", color="red", label="actual")
    ax1.legend(loc="upper right", frameon=False)
    ax1.grid(True)
    p2, = ax2.plot_date([], [], fmt="-", color="red", label="anomaly score")
    ax2.legend(loc="upper right", frameon=False)
    ax2.axhline(0.8, color='black', lw=2)
    # add the x/y label
    ax2.set_xlabel("date time")
    ax2.set_ylabel("anomaly score")
    ax1.set_ylabel("value")
    # add the table in ax3
    col_labels = ["date time", 'actual value', 'predict value', 'anomaly score']
    ax3.text(0.05, 0.99, "anomaly value table", size=12)
    ax3.set_xticks([])
    ax3.set_yticks([])
    
    # axis format
    dateFormat = DateFormatter("%m/%d %H:%M")
    ax1.xaxis.set_major_formatter(ticker.FuncFormatter(dateFormat))
    ax2.xaxis.set_major_formatter(ticker.FuncFormatter(dateFormat))
    
    
    # define the initial function
    def init():
        p1.set_data([], [])
        p2.set_data([], [])
        return p1, p2
    
    
    # initial data for the update function
    x1 = []
    x2 = []
    x1_2 = []
    y1_2 = []
    x1_3 = []
    y1_3 = []
    y1 = []
    y2 = []
    highlightList = []
    turnOn = True
    tableValue = [[0, 0, 0, 0]]
    
    
    # update function
    def stream(i):
        # update the main graph(contains actual value and predicted value)
        # add the data
        global turnOn, highlightList, ax3
    
        x1.append(timestamp[i])
        y1.append(value_a[i])
        # update the axis
        minAxis = max(x1) - datetime.timedelta(days=1)
        ax1.set_xlim(minAxis, max(x1))
        ax1.set_ylim(min(y1), max(y1))
        ax1.figure.canvas.draw()
        p1.set_data(x1, y1)
    
        # update the anomaly graph(contains anomaly score)
        x2.append(timestamp[i])
        y2.append(anomalyScore_a[i])
        ax2.set_xlim(minAxis, max(x2))
        ax2.set_ylim(min(y2), max(y2))
    
        # update the scatter
        if anomalyScore_a[i] >= 0.8:
            x1_3.append(timestamp[i])
            y1_3.append(value_a[i])
            ax1.scatter(x1_3, y1_3, s=50, color="black")
    
        # update the high light
        if anomalyScore_a[i] >= 0.8:
            highlightList.append(i)
            turnOn = True
        else:
            turnOn = False
        if len(highlightList) != 0 and turnOn is False:
    
            ax2.axvspan(timestamp[min(highlightList)] - datetime.timedelta(minutes=10),
                        timestamp[max(highlightList)] + datetime.timedelta(minutes=10),
                        color='r',
                        edgecolor=None,
                        alpha=0.2)
            highlightList = []
            turnOn = True
        p2.set_data(x2, y2)
    
        # add the table in ax3
        # update the anomaly tabel
        if anomalyScore_a[i] >= 0.8:
            ax3.remove()
            ax3 = fig.add_axes([0.8, 0.1, 0.2, 0.8], frameon=False)
            ax3.text(0.05, 0.99, "anomaly value table", size=12)
            ax3.set_xticks([])
            ax3.set_yticks([])
            tableValue.append([timestamp[i].strftime("%Y-%m-%d %H:%M:%S"), value_a[i], predict_a[i], anomalyScore_a[i]])
            if len(tableValue) >= 40: tableValue.pop(0)
            ax3.table(cellText=tableValue, colWidths=[0.35] * 4, colLabels=col_labels, loc=1, cellLoc="center")
    
        return p1, p2
    
    
    # main animated function
    anim = FuncAnimation(fig, stream, init_func=init, frames=len(timestamp), interval=0)
    
    plt.show()
    file.close()
    • 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
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154

    ion版本

    #! /usr/bin/python
    
    import os
    import csv
    import datetime
    import matplotlib.pyplot as plt
    from matplotlib.animation import FuncAnimation
    from matplotlib.dates import DateFormatter
    import matplotlib.ticker as ticker
    
    
    class streamDetectionPlot(object):
        """
        Anomaly plot output.
        """
    
        # initial the figure parameters.
        def __init__(self):
            # Turn matplotlib interactive mode on.
            plt.ion()
            # initial the plot variable.
            self.timestamp = []
            self.actualValue = []
            self.predictValue = []
            self.anomalyScore = []
            self.tableValue = [[0, 0, 0, 0]]
            self.highlightList = []
            self.highlightListTurnOn = True
            self.anomalyScoreRange = [0, 1]
            self.actualValueRange = [0, 1]
            self.predictValueRange = [0, 1]
            self.timestampRange = [0, 1]
            self.anomalyScatterX = []
            self.anomalyScatterY = []
    
            # initial the figure.
            global fig
            fig = plt.figure(figsize=(18, 8), facecolor="white")
            fig.subplots_adjust(left=0.06, right=0.70)
            self.actualPredictValueGraph = fig.add_subplot(2, 1, 1)
            self.anomalyScoreGraph = fig.add_subplot(2, 1, 2)
            self.anomalyValueTable = fig.add_axes([0.8, 0.1, 0.2, 0.8], frameon=False)
    
        # define the initial plot method.
        def initPlot(self):
            # initial two lines of the actualPredcitValueGraph.
            self.actualLine, = self.actualPredictValueGraph.plot_date(self.timestamp, self.actualValue, fmt="-",
                                                                      color="red", label="actual value")
            self.predictLine, = self.actualPredictValueGraph.plot_date(self.timestamp, self.predictValue, fmt="-",
                                                                       color="blue", label="predict value")
            self.actualPredictValueGraph.legend(loc="upper right", frameon=False)
            self.actualPredictValueGraph.grid(True)
    
            # initial two lines of the anomalyScoreGraph.
            self.anomalyScoreLine, = self.anomalyScoreGraph.plot_date(self.timestamp, self.anomalyScore, fmt="-",
                                                                      color="red", label="anomaly score")
            self.anomalyScoreGraph.legend(loc="upper right", frameon=False)
            self.baseline = self.anomalyScoreGraph.axhline(0.8, color='black', lw=2)
    
            # set the x/y label of the first two graph.
            self.anomalyScoreGraph.set_xlabel("datetime")
            self.anomalyScoreGraph.set_ylabel("anomaly score")
            self.actualPredictValueGraph.set_ylabel("value")
    
            # configure the anomaly value table.
            self.anomalyValueTableColumnsName = ["timestamp", "actual value", "expect value", "anomaly score"]
            self.anomalyValueTable.text(0.05, 0.99, "Anomaly Value Table", size=12)
            self.anomalyValueTable.set_xticks([])
            self.anomalyValueTable.set_yticks([])
    
            # axis format.
            self.dateFormat = DateFormatter("%m/%d %H:%M")
            self.actualPredictValueGraph.xaxis.set_major_formatter(ticker.FuncFormatter(self.dateFormat))
            self.anomalyScoreGraph.xaxis.set_major_formatter(ticker.FuncFormatter(self.dateFormat))
    
    
        # define the output method.
        def anomalyDetectionPlot(self, timestamp, actualValue, predictValue, anomalyScore):
    
            # update the plot value of the graph.
            self.timestamp.append(timestamp)
            self.actualValue.append(actualValue)
            self.predictValue.append(predictValue)
            self.anomalyScore.append(anomalyScore)
    
            # update the x/y range.
            self.timestampRange = [min(self.timestamp), max(self.timestamp)+datetime.timedelta(minutes=10)]
            self.actualValueRange = [min(self.actualValue), max(self.actualValue)+1]
            self.predictValueRange = [min(self.predictValue), max(self.predictValue)+1]
    
            # update the x/y axis limits
            self.actualPredictValueGraph.set_ylim(
                min(self.actualValueRange[0], self.predictValueRange[0]),
                max(self.actualValueRange[1], self.predictValueRange[1])
            )
            self.actualPredictValueGraph.set_xlim(
                self.timestampRange[1] - datetime.timedelta(days=1),
                self.timestampRange[1]
            )
            self.anomalyScoreGraph.set_xlim(
                self.timestampRange[1]- datetime.timedelta(days=1),
                self.timestampRange[1]
            )
            self.anomalyScoreGraph.set_ylim(
                self.anomalyScoreRange[0],
                self.anomalyScoreRange[1]
            )
    
            # update the two lines of the actualPredictValueGraph.
            self.actualLine.set_xdata(self.timestamp)
            self.actualLine.set_ydata(self.actualValue)
            self.predictLine.set_xdata(self.timestamp)
            self.predictLine.set_ydata(self.predictValue)
    
            # update the line of the anomalyScoreGraph.
            self.anomalyScoreLine.set_xdata(self.timestamp)
            self.anomalyScoreLine.set_ydata(self.anomalyScore)
    
            # update the scatter.
            if anomalyScore >= 0.8:
                self.anomalyScatterX.append(timestamp)
                self.anomalyScatterY.append(actualValue)
                self.actualPredictValueGraph.scatter(
                    self.anomalyScatterX,
                    self.anomalyScatterY,
                    s=50,
                    color="black"
                )
    
            # update the highlight of the anomalyScoreGraph.
            if anomalyScore >= 0.8:
                self.highlightList.append(timestamp)
                self.highlightListTurnOn = True
            else:
                self.highlightListTurnOn = False
            if len(self.highlightList) != 0 and self.highlightListTurnOn is False:
                self.anomalyScoreGraph.axvspan(
                    self.highlightList[0] - datetime.timedelta(minutes=10),
                    self.highlightList[-1] + datetime.timedelta(minutes=10),
                    color="r",
                    edgecolor=None,
                    alpha=0.2
                )
                self.highlightList = []
                self.highlightListTurnOn = True
    
            # update the anomaly value table.
            if anomalyScore >= 0.8:
                # remove the table and then replot it
                self.anomalyValueTable.remove()
                self.anomalyValueTable = fig.add_axes([0.8, 0.1, 0.2, 0.8], frameon=False)
                self.anomalyValueTableColumnsName = ["timestamp", "actual value", "expect value", "anomaly score"]
                self.anomalyValueTable.text(0.05, 0.99, "Anomaly Value Table", size=12)
                self.anomalyValueTable.set_xticks([])
                self.anomalyValueTable.set_yticks([])
                self.tableValue.append([
                    timestamp.strftime("%Y-%m-%d %H:%M:%S"),
                    actualValue,
                    predictValue,
                    anomalyScore
                ])
                if len(self.tableValue) >= 40: self.tableValue.pop(0)
                self.anomalyValueTable.table(cellText=self.tableValue,
                                             colWidths=[0.35] * 4,
                                             colLabels=self.anomalyValueTableColumnsName,
                                             loc=1,
                                             cellLoc="center"
                                             )
    
            # plot pause 0.0001 second and then plot the next one.
            plt.pause(0.0001)
            plt.draw()
    
        def close(self):
            plt.ioff()
            plt.show()
    
    • 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
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177

    下面是ion版本的调用:

    graph = stream_detection_plot.streamDetectionPlot()
    graph.initPlot()
    
    for i in xrange(len(timestamp)):
        graph.anomalyDetectionPlot(timestamp[i],value_a[i],predict_a[i],anomalyScore_a[i])
    
    graph.close()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    具体为实例化类,初始化图形,传入数据作图,关掉。

    大概就是这样,有什么不对多指出,谢谢~

    展开全文
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • Python疫情监控完整项目实战

    千人学习 2019-04-13 10:48:48
    基于Python + Echarts + Flask打造的... 亮点三:实战指引 基于真实业务场景,打造实战项目案例,整合多项技术:网络爬虫(Python)、前端数据可视化(Echarts)、Web框架(Flask)、后台服务(Python + Pyecharts)。
  • Heartrate 是一个 Python 的工具库,可以实时可视化 Python 程序的执行过程。监控运行中的 Python 程序如图: 如图所示,左侧数字表示每行代码被触发的次数。长方框表示最近被触发的代码行——方框越长表示触发次数...
  • 它适用于Jupyter Notebook,可显示机器学习训练的实时可视化,并执行模型和数据的其他几个关键可视化。 TensorWatch支持Python 3.x,并使用PyTorch 0.4-1.x进行测试。大多数功能也可以与TensorFlow Eager tensors...
  • wordcloud 库,数据可视化用 pyecharts 绘制的地图和折线图,数据储存在 Excel 表格里面,使用 openpyxl 对表格进行处理。 本程序实现了累计确诊地图展示和每日数据变化折线图展示,其他更多数据的获取和展示均可在...
  • 三维可视化系统的建立依赖于三维图形平台, 如 OpenGL、VTK、OGRE、OSG等, 传统的方法多采用OpenGL进行底层编程,即对其特有的函数进行定量操作, 需要开发人员熟悉相关函数, 从而造成了开发难度大、 周期长等问题...

空空如也

空空如也

1 2 3 4
收藏数 77
精华内容 30
关键字:

python实时监控可视化

python 订阅