最近在统计资产，正好看到了xlsxwriter这个表格生成模块，借此机会，熟悉一下，写点有趣的小案例，一开始想使用C++ QT图形化开发一套自动化运维平台，但后来发现不仅消耗时间而且需要解决QT Qssh远程模块的一些问题，后来没有使用QT做，xlsxwriter模块来做非常的简单，所以使用它。

上班不能摸鱼，我要努力摸鱼，不不不，学习，不然今天我摸鱼，明天鱼摸我。。

绘制磁盘统计（封装表格）

封装前需要先来找出规律: 先找到表格生成坐标与大小之间的比值关系，这是第一步。

  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook('chart_line.xlsx')
  5. worksheet3 = workbook.add_worksheet("系统磁盘统计")
  6. merge_format = workbook.add_format({
  7.     'bold':     True,
  8.     'border':   1,
  9.     'align':    'center',
  10.     'valign':   'vcenter',
  11.     'fg_color': '#EEAEEE',
  12. })
  14. worksheet3.merge_range('A9:B12', '192.168.1.1', merge_format)
  15. # -------------------------------------------------------------------------
  17. head = ["IP地址","IP地址","路径","总容量","剩余容量","利用率"]
  18. merge_format1 = workbook.add_format({
  19.     'bold':     True,
  20.     'border':   1,
  21.     'align':    'center',#水平居中
  22.     'valign':   'vcenter',#垂直居中
  23.     'fg_color': '#AEEEEE',#颜色填充
  24. })
  25. worksheet3.write_row("A8:B12",head,merge_format1)        #显示表头
  26. worksheet3.merge_range('A8:B8',"IP地址",merge_format1)   # 合并表头(合并第一个元素)
  28. data1 = ["/etc/system/winsss/aaa","/proc/","/sys","/abc/lyshark"]
  29. merge_format2 = workbook.add_format\
  30.         ({'bold': True,'border': 1,'valign': 'vcenter','fg_color': '#D7E4BC','align': 'center'})
  32. worksheet3.write_column("C9",data1,merge_format2)
  33. worksheet3.set_column("C9:C9",30)
  35. data2 = ["1024GG","2048GB","111GB","1111GB"]
  36. merge_format3 = workbook.add_format\
  37.         ({'bold': True,'border': 1,'valign': 'vcenter','fg_color': '#D7E4BC','align': 'center'})
  38. worksheet3.write_column("D9",data2,merge_format3)
  39. worksheet3.set_column("D9:D9",20)
  41. data3 = ["1024GG","2048GB","111GB","22GB"]
  42. merge_format4 = workbook.add_format\
  43.         ({'bold': True,'border': 1,'valign': 'vcenter','fg_color': '#D7E4BC','align': 'center'})
  44. worksheet3.write_column("E9",data3,merge_format4)
  45. worksheet3.set_column("E9:E9",20)
  47. data4= ["10%","50%","20%","33%"]
  48. merge_format5 = workbook.add_format\
  49.         ({'bold': True,'border': 1,'valign': 'vcenter','fg_color': '#D7E4BC','align': 'center'})
  50. worksheet3.write_column("F9",data4,merge_format5)
  51. worksheet3.set_column("F9:F9",20)
  53. '''
  54. val =
  55. [
  56.     ["IP地址","IP地址","路径","总容量","剩余容量","利用率"]，
  57.     ["/etc/","/proc","/user","/test","lyshark"],
  58.     ["1GB","2GB","3GB","4GB","5GB"],
  59.     ["1GB","2GB","3GB","4GB","5GB"],
  60.     ["10%","10%","10%","10%","10%"]
  61. ]
  63. SetDiskTable(address,val)
  64. '''
  65. workbook.close()

接着对其进行封装:找到规律后就要对其进行封装，封装成一个可直接调用的方法。

  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook('chart_line.xlsx')
  4. worksheet = workbook.add_worksheet("系统磁盘统计")
  6. def CreateDiskTable(address,data,section):
  7.     merge_format = workbook.add_format(
  8.         {'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#EEAEEE'})
  10.     header_count = len(data[1])
  11.     merge_format1 = workbook.add_format(
  12.         {'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#AEEEEE'})
  14.     # 根据磁盘路径计算出表格大小
  15.     header_range = "A{}:B{}".format(section,section+header_count)
  16.     worksheet.write_row(header_range, data[0], merge_format1)  # 显示表头
  18.     # 计算合并表头偏移
  19.     header_merge_range = "A{}:B{}".format(section,section)
  20.     worksheet.merge_range(header_merge_range, "IP地址", merge_format1)  # 合并表头(合并第一个元素)
  22.     # 计算出地址所占总单元格大小
  23.     address_merge_range = "A{}:B{}".format(section+1,section+header_count)
  24.     worksheet.merge_range(address_merge_range, address , merge_format)  #需要计算出来，根据传入分区数量
  26.     # 通过计算得到磁盘路径所对应到表中的位置
  27.     merge_format2 = workbook.add_format(
  28.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  30.     index_range = "C{}".format(section+1)
  31.     worksheet.write_column(index_range, data[1], merge_format2)
  32.     index_range = "C{}:C{}".format(section+1,section+1)
  33.     worksheet.set_column(index_range, 30)
  35.     # 计算出总容量对应到表中的位置
  36.     merge_format3 = workbook.add_format(
  37.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  39.     index_range = "D{}".format(section + 1)
  40.     worksheet.write_column(index_range, data[2], merge_format3)
  42.     index_range = "D{}:D{}".format(section + 1, section + 1)
  43.     worksheet.set_column(index_range, 20)
  45.     # 计算出剩余容量对应到表中的位置
  46.     merge_format4 = workbook.add_format(
  47.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  48.     index_range = "E{}".format(section + 1)
  49.     worksheet.write_column(index_range, data[3], merge_format4)
  50.     index_range = "E{}:E{}".format(section + 1, section + 1)
  51.     worksheet.set_column(index_range, 20)
  53.     # 计算出利用率对应到表中的位置
  54.     merge_format5 = workbook.add_format(
  55.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  57.     index_range = "F{}".format(section + 1)
  58.     worksheet.write_column(index_range, data[4], merge_format5)
  59.     index_range = "F{}:F{}".format(section + 1, section + 1)
  60.     worksheet.set_column(index_range, 20)
  62.     # 返回计算后的表格的下两个单元的实际偏移位置
  63.     return section + header_count + 3
  65. if __name__ == "__main__":
  66.     val = \
  67.     [
  68.         ["IP地址", "IP地址", "磁盘路径", "总容量", "剩余容量", "利用率"],
  69.         ["/etc/system/winsss/aaa", "/proc/", "/sys", "/abc/lyshark"],
  70.         ["1024GG", "2048GB", "111GB", "1111GB"],
  71.         ["1024GG", "2048GB", "111GB", "22GB"],
  72.         ["10%", "50%", "20%", "33%"]
  73.     ]
  75.     ref = CreateDiskTable("192.168.1.1",val,8)
  76.     print(ref)
  77.     ref = CreateDiskTable("192.168.1.1", val, ref)
  78.     CreateDiskTable("192.168.1.1", val, ref)
  79.     workbook.close()

继续更新一下

  1. import xlsxwriter
  2. import json,os,sys,math
  3. import argparse
  4. import paramiko
  6. workbook = xlsxwriter.Workbook('disk.xlsx')
  7. worksheet = workbook.add_worksheet("系统磁盘统计")
  9. ssh = paramiko.SSHClient()
  10. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  12. def BatchCMD(address,username,password,port,command):
  13.     try:
  14.         ssh.connect(hostname=address,username=username,password=password,port=port,timeout=2)
  15.         stdin , stdout , stderr = ssh.exec_command(command)
  16.         result = stdout.read()
  17.         if len(result) != 0:
  18.             result = str(result).replace("\\n", "\n")
  19.             result = result.replace("b'", "").replace("'", "")
  20.             return result
  21.         else:
  22.             return None
  23.     except Exception:
  24.         return None
  26. def GetAllDiskSpace(address,username,password,port):
  27.     ref = []
  28.     cmd_dict = {"Linux\n" : "df | grep -v 'Filesystem' | awk '{print $6 \":\" $3 \":\" $4 \":\" $5}'",
  29.                 "AIX\n" : "df | grep -v 'Filesystem' | awk '{print $4 \":\" $7}'"
  30.                 }
  31.     os_version = BatchCMD(address,username,password,port,"uname")
  32.     for version,run_cmd in cmd_dict.items():
  33.         if(version == os_version):
  34.             os_ref = BatchCMD(address,username,password,port,run_cmd)
  35.             ref_list= os_ref.split("\n")
  36.             for each in ref_list:
  37.                 if each != "":
  38.                     ref_list = []
  39.                     ref_list = str(each.split(":"))
  40.                     ref.append(eval(ref_list))
  41.     return ref
  43. def CreateDiskTable(address,data,section):
  44.     merge_format = workbook.add_format(
  45.         {'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#EEAEEE'})
  47.     header_count = len(data[1])
  48.     merge_format1 = workbook.add_format(
  49.         {'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#AEEEEE'})
  51.     # 根据磁盘路径计算出表格大小
  52.     header_range = "A{}:B{}".format(section,section+header_count)
  53.     worksheet.write_row(header_range, data[0], merge_format1)  # 显示表头
  55.     # 计算合并表头偏移
  56.     header_merge_range = "A{}:B{}".format(section,section)
  57.     worksheet.merge_range(header_merge_range, "IP地址", merge_format1)  # 合并表头(合并第一个元素)
  59.     # 计算出地址所占总单元格大小
  60.     address_merge_range = "A{}:B{}".format(section+1,section+header_count)
  61.     worksheet.merge_range(address_merge_range, address , merge_format)  #需要计算出来，根据传入分区数量
  63.     # 通过计算得到磁盘路径所对应到表中的位置
  64.     merge_format2 = workbook.add_format(
  65.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  67.     index_range = "C{}".format(section+1)
  68.     worksheet.write_column(index_range, data[1], merge_format2)
  69.     index_range = "C{}:C{}".format(section+1,section+1)
  70.     worksheet.set_column(index_range, 30)
  72.     # 计算出总容量对应到表中的位置
  73.     merge_format3 = workbook.add_format(
  74.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  76.     index_range = "D{}".format(section + 1)
  77.     worksheet.write_column(index_range, data[2], merge_format3)
  79.     index_range = "D{}:D{}".format(section + 1, section + 1)
  80.     worksheet.set_column(index_range, 20)
  82.     # 计算出剩余容量对应到表中的位置
  83.     merge_format4 = workbook.add_format(
  84.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  85.     index_range = "E{}".format(section + 1)
  86.     worksheet.write_column(index_range, data[3], merge_format4)
  87.     index_range = "E{}:E{}".format(section + 1, section + 1)
  88.     worksheet.set_column(index_range, 20)
  90.     # 计算出利用率对应到表中的位置
  91.     merge_format5 = workbook.add_format(
  92.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  94.     index_range = "F{}".format(section + 1)
  95.     worksheet.write_column(index_range, data[4], merge_format5)
  96.     index_range = "F{}:F{}".format(section + 1, section + 1)
  97.     worksheet.set_column(index_range, 20)
  99.     # 返回计算后的表格的下两个单元的实际偏移位置
  100.     return section + header_count + 3
  102. if __name__ == "__main__":
  104.     '''
  105.     val = \
  106.     [
  107.         ["IP地址", "IP地址", "磁盘路径", "总容量", "剩余容量", "利用率"],
  108.         ["/etc/system/winsss/aaa", "/proc/", "/sys", "/abc/lyshark"],
  109.         ["1024GG", "2048GB", "111GB", "1111GB"],
  110.         ["1024GG", "2048GB", "111GB", "22GB"],
  111.         ["10%", "50%", "20%", "33%"]
  112.     ]
  113.     ref = CreateDiskTable("192.168.1.1",val,3)
  114.     ref = CreateDiskTable("192.168.1.2", val, ref)
  115.     CreateDiskTable("192.168.1.3", val, ref)
  116.     '''
  118.     ref = GetAllDiskSpace("192.168.191.4","root","1233",22)
  120.     # 恒矩阵转树矩阵
  121.     ref_xor = list ( map(list,zip(*ref)) )
  123.     header = ["IP地址", "IP地址", "磁盘路径", "已使用", "剩余容量", "利用率"]
  125.     ref_xor.insert(0,header)
  126.     print(ref_xor)
  128.     CreateDiskTable("192.168.191.4", ref_xor, 2)
  129.     workbook.close()

增加SSH功能遵循调用规范：

  1. import xlsxwriter
  2. import paramiko
  3. import os,sys,datetime
  5. disk_name = "disk_" + str(datetime.datetime.now()).split(" ")[0] + ".xlsx"
  7. workbook = xlsxwriter.Workbook(disk_name)
  8. worksheet = workbook.add_worksheet("系统磁盘统计")
  10. ssh = paramiko.SSHClient()
  11. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  13. # 封装远程命令执行
  14. def BatchCMD(address,username,password,port,command):
  15.     try:
  16.         ssh.connect(hostname=address,username=username,password=password,port=port,timeout=2)
  17.         stdin , stdout , stderr = ssh.exec_command(command)
  18.         result = stdout.read()
  19.         if len(result) != 0:
  20.             result = str(result).replace("\\n", "\n")
  21.             result = result.replace("b'", "").replace("'", "")
  22.             return result
  23.         else:
  24.             return None
  25.     except Exception:
  26.         return None
  28. # 获取磁盘数据
  29. def GetAllDiskSpace(address,username,password,port):
  30.     ref = []
  31.     cmd_dict = {"Linux\n" : "df | grep -v 'Filesystem' | awk '{print $6 \":\" $3 \":\" $4 \":\" $5}'",
  32.                 "AIX\n" : "df | grep -v 'Filesystem' | awk '{print $7 \":\" $5 \":\" $3 \":\" $4}'"
  33.                 }
  34.     os_version = BatchCMD(address,username,password,port,"uname")
  35.     for version,run_cmd in cmd_dict.items():
  36.         if(version == os_version):
  37.             os_ref = BatchCMD(address,username,password,port,run_cmd)
  38.             ref_list= os_ref.split("\n")
  39.             for each in ref_list:
  40.                 if each != "":
  41.                     ref_list = str(each.split(":"))
  42.                     ref.append(eval(ref_list))
  43.     return ref
  45. # 封装的绘制主机表格方法
  46. def CreateDiskTable(address,data,section):
  47.     merge_format = workbook.add_format(
  48.         {'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#EEAEEE'})
  50.     header_count = len(data[1])
  51.     merge_format1 = workbook.add_format(
  52.         {'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#AEEEEE'})
  54.     # 根据磁盘路径计算出表格大小
  55.     header_range = "A{}:B{}".format(section,section+header_count)
  56.     worksheet.write_row(header_range, data[0], merge_format1)  # 显示表头
  58.     # 计算合并表头偏移
  59.     header_merge_range = "A{}:B{}".format(section,section)
  60.     worksheet.merge_range(header_merge_range, "巡检IP地址", merge_format1)  # 合并表头(合并第一个元素)
  62.     # 计算出地址所占总单元格大小
  63.     address_merge_range = "A{}:B{}".format(section+1,section+header_count)
  64.     worksheet.merge_range(address_merge_range, address , merge_format)  #需要计算出来，根据传入分区数量
  66.     # 通过计算得到磁盘路径所对应到表中的位置
  67.     merge_format2 = workbook.add_format(
  68.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC'})
  70.     index_range = "C{}".format(section+1)
  71.     worksheet.write_column(index_range, data[1], merge_format2)
  72.     index_range = "C{}:C{}".format(section+1,section+1)
  73.     worksheet.set_column(index_range, 30)
  75.     # 计算出总容量对应到表中的位置
  76.     merge_format3 = workbook.add_format(
  77.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  79.     index_range = "D{}".format(section + 1)
  80.     worksheet.write_column(index_range, data[2], merge_format3)
  82.     index_range = "D{}:D{}".format(section + 1, section + 1)
  83.     worksheet.set_column(index_range, 20)
  85.     # 计算出剩余容量对应到表中的位置
  86.     merge_format4 = workbook.add_format(
  87.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  88.     index_range = "E{}".format(section + 1)
  89.     worksheet.write_column(index_range, data[3], merge_format4)
  90.     index_range = "E{}:E{}".format(section + 1, section + 1)
  91.     worksheet.set_column(index_range, 20)
  93.     # 计算出利用率对应到表中的位置
  94.     merge_format5 = workbook.add_format(
  95.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  97.     index_range = "F{}".format(section + 1)
  98.     worksheet.write_column(index_range, data[4], merge_format5)
  99.     index_range = "F{}:F{}".format(section + 1, section + 1)
  100.     worksheet.set_column(index_range, 20)
  102.     # 返回计算后的表格的下两个单元的实际偏移位置
  103.     return section + header_count + 3
  105. if __name__ == "__main__":
  106.     with open("./unix_disk.db","r") as fp:
  107.         fp_file = fp.readlines()
  109.         ref_index = 2
  110.         for each in fp_file:
  111.             data = eval(each)
  112.             ref = GetAllDiskSpace(data[0], data[2], data[3], 22)
  113.             try:
  114.                 print("[+] 正在绘制 {} 表格数据,这是一台: {} 主机".format(data[0],data[1]))
  115.                 # 恒矩阵转树矩阵
  116.                 ref_xor = list(map(list, zip(*ref)))
  117.                 header = ["IP地址", "IP地址", "磁盘路径", "已使用", "剩余容量", "利用率"]
  119.                 # 将表头追加到矩阵头部
  120.                 ref_xor.insert(0, header)
  122.                 # 绘制表格,ref_index 递归自身,每次定位到下一个需要更新的表
  123.                 ref_index = CreateDiskTable(data[0], ref_xor, ref_index)
  124.             except Exception:
  125.                 pass
  126.     workbook.close()

绘制内存统计图(柱状图)

简单的案例： 主要统计前十计数信息，先远程拉取数据，然后内部矩阵排序，关联柱状图前十个元素，即可。

  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook("xxx.xlsx")
  4. worksheet = workbook.add_worksheet()
  6. headings = ["主机地址", "CPU利用率", "内存利用率","交换分区"]
  7. data = [["192.168.1.100", 88, 36,66], ["192.168.1.200", 98, 89,66], ["192.168.1.220", 88, 100,32]]
  9. # 循环添加模拟数据
  10. for i in range(1,100):
  11.     s = ["192.168.1.{}".format(i),i,i,i]
  12.     data.append(s)
  14. # 定义表格样式
  15. head_style = workbook.add_format({"bold": True, "align": "center", "font": 13})
  17. # 逐条写入数据
  18. worksheet.write_row("A1", headings, head_style)
  19. for i in range(0, len(data)):
  20.     worksheet.write_row("A{}".format(i + 2), data[i])
  22. # 添加柱状图
  23. chart = workbook.add_chart({"type": "column"})
  24. chart.add_series({
  25.     "name": "=Sheet1!$B$1",             # 图例项
  26.     "categories": "=Sheet1!$A$2:$A$10",  # X轴 Item名称
  27.     "values": "=Sheet1!$B$2:$B$10"       # X轴Item值
  28. })
  29. chart.add_series({
  30.     "name": "=Sheet1!$C$1",
  31.     "categories": "=Sheet1!$A$2:$A$10",
  32.     "values": "=Sheet1!$C$2:$C$10"
  33. })
  34. chart.add_series({
  35.     "name": "=Sheet1!$D$1",
  36.     "categories": "=Sheet1!$A$2:$A$10",
  37.     "values": "=Sheet1!$D$2:$D$10"
  38. })
  40. # 添加柱状图标题
  41. chart.set_title({"name": "性能统计柱状图"})
  42. chart.set_style(12)
  44. # 在G2处绘制
  45. worksheet.insert_chart("G2", chart)
  46. workbook.close()

先来获取到CPU数据： 通过SSH拉取CPU数据，然后按照最后一个值进行排序，由大到小以此放入二维数组中。

  1. import xlsxwriter
  2. import paramiko
  4. ssh = paramiko.SSHClient()
  5. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  7. def BatchCMD(address,username,password,port,command):
  8.     try:
  9.         ssh.connect(hostname=address,username=username,password=password,port=port,timeout=2)
  10.         stdin , stdout , stderr = ssh.exec_command(command)
  11.         result = stdout.read()
  12.         if len(result) != 0:
  13.             result = str(result).replace("\\n", "\n")
  14.             result = result.replace("b'", "").replace("'", "")
  15.             return result
  16.         else:
  17.             return None
  18.     except Exception:
  19.         return None
  21. def GetMemLoad(address,username,password,port):
  22.     ref = []
  23.     cmd_dict = {"Linux\n" : "free | grep \"Mem\" | awk '{print $2 \":\" $4}'",
  24.                 "AIX\n" : "svmon | grep \"memory\" | awk '{print $2 \":\" $4}'"
  25.                 }
  26.     # aix 总大小、剩余大小 需要x4
  27.     os_version = BatchCMD(address,username,password,port,"uname")
  28.     for version,run_cmd in cmd_dict.items():
  29.         if(version == os_version):
  30.             os_ref = BatchCMD(address,username,password,port,run_cmd)
  31.             ref_list= os_ref.split("\n")
  32.             for each in ref_list:
  33.                 if each != "":
  34.                     print(each)
  35.     return ref
  37. def GetCPULoad(address,username,password,port):
  38.     ref = []
  39.     # 用户占用，系统占用，空闲
  40.     cmd_dict = {"Linux\n" : "vmstat | tail -n 1 | awk '{print $13 \":\" $14 \":\" $15}'",
  41.                 "AIX\n" : "vmstat | tail -n 1 | awk '{print $14 \":\" $15 \":\" $16}'"
  42.                 }
  43.     os_version = BatchCMD(address,username,password,port,"uname")
  44.     for version,run_cmd in cmd_dict.items():
  45.         if(version == os_version):
  46.             os_ref = BatchCMD(address,username,password,port,run_cmd)
  47.             ref_list= os_ref.split("\n")
  48.             for each in ref_list:
  49.                 if each != "":
  50.                     ref = each.split(":")
  51.             ref[2] = str(100 - int(ref[2]))
  52.             ref.insert(0,address)
  53.     return ref
  55. # 排序函数,以第三列为条件排列
  56. def takeSecond(elem):
  57.     return int(elem[3])
  59. if __name__ == "__main__":
  60.     workbook = xlsxwriter.Workbook("test1111.xlsx")
  61.     worksheet = workbook.add_worksheet()
  63.     # 设置头部数据
  64.     headings = ["主机地址", "CPU内核态", "CPU用户态", "总利用率"]
  65.     head_style = workbook.add_format({"bold": True, "align": "center" ,"fg_color":"#D7E4BC"})
  66.     worksheet.write_row("A1", headings, head_style)
  68.     # 设置头部列宽
  69.     worksheet.set_column("A1:D1",15)
  71. # 统计数据并排序
  72.     cpu_data = []
  73.     with open("./unix_disk.db","r") as fp:
  74.         fp_file = fp.readlines()
  75.         for each in fp_file:
  76.             try:
  77.                 data = eval(each)
  78.                 ref = GetCPULoad(data[0], data[2], data[3], 22)
  80.                 if(len(ref) !=0):
  81.                     cpu_data.append(ref)
  82.                 else:
  83.                     continue
  84.             except Exception:
  85.                 pass
  87.     # 排序,统计第三列数据，将最大的放在最前面，以此向下
  88.     cpu_data.sort(key=takeSecond, reverse=True)
  89.     print(cpu_data)
  91.     for i in range(0, len(cpu_data)):
  92.         worksheet.write_row("A{}".format(i + 2), cpu_data[i])
  93.     workbook.close()

将绘图方法与SSH结合： 运行后即可统计出机器的所有CPU数据，并将排名前十的机器使用情况列出来。

  1. import xlsxwriter
  2. import paramiko
  4. ssh = paramiko.SSHClient()
  5. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  7. workbook = xlsxwriter.Workbook("test333.xlsx")
  8. worksheet = workbook.add_worksheet()
  10. def BatchCMD(address,username,password,port,command):
  11.     try:
  12.         ssh.connect(hostname=address,username=username,password=password,port=port,timeout=2)
  13.         stdin , stdout , stderr = ssh.exec_command(command)
  14.         result = stdout.read()
  15.         if len(result) != 0:
  16.             result = str(result).replace("\\n", "\n")
  17.             result = result.replace("b'", "").replace("'", "")
  18.             return result
  19.         else:
  20.             return None
  21.     except Exception:
  22.         return None
  24. def GetCPULoad(address,username,password,port):
  25.     ref = []
  26.     # 用户占用，系统占用，空闲
  27.     cmd_dict = {"Linux\n" : "vmstat | tail -n 1 | awk '{print $13 \":\" $14 \":\" $15}'",
  28.                 "AIX\n" : "vmstat | tail -n 1 | awk '{print $14 \":\" $15 \":\" $16}'"
  29.                 }
  30.     os_version = BatchCMD(address,username,password,port,"uname")
  31.     for version,run_cmd in cmd_dict.items():
  32.         if(version == os_version):
  33.             os_ref = BatchCMD(address,username,password,port,run_cmd)
  34.             ref_list= os_ref.split("\n")
  35.             for each in ref_list:
  36.                 if each != "":
  37.                     ref = each.split(":")
  38.             ref[2] = str(100 - int(ref[2]))
  39.             ref.insert(0,address)
  41.     ref[1] = int(ref[1])
  42.     ref[2] = int(ref[2])
  43.     ref[3] = int(ref[3])
  44.     return ref
  46. # 排序函数,以第三列为条件排列
  47. def takeSecond(elem):
  48.     return int(elem[3])
  50. # 添加柱状统计图
  51. def AddGraphical():
  52.     # 添加柱状图
  53.     chart = workbook.add_chart({"type": "column"})
  54.     chart.add_series({
  55.         "name": "=Sheet1!$B$1",  # 图例项(也就是CPU内核态)
  56.         "categories": "=Sheet1!$A$2:$A$10",  # X轴 Item名称
  57.         "values": "=Sheet1!$B$2:$B$10"  # X轴Item值
  58.     })
  59.     chart.add_series({
  60.         "name": "=Sheet1!$C$1",
  61.         "categories": "=Sheet1!$A$2:$A$10",
  62.         "values": "=Sheet1!$C$2:$C$10"
  63.     })
  64.     chart.add_series({
  65.         "name": "=Sheet1!$D$1",
  66.         "categories": "=Sheet1!$A$2:$A$10",
  67.         "values": "=Sheet1!$D$2:$D$10"
  68.     })
  70.     # 添加柱状图标题
  71.     chart.set_title({"name": "CPU 性能统计柱状图"})
  72.     # chart.set_style(8)
  74.     chart.set_x_axis({
  75.         'major_gridlines': {
  76.             'visible': True,
  77.             'line': {'width': 1.25, 'dash_type': 'dash'}
  78.         },
  79.     })
  81.     chart.set_size({'width': 900, 'height': 500})
  82.     chart.set_legend({'position': 'top'})
  83.     chart.set_table({'show_keys': True})
  85.     # 在F2处绘制
  86.     worksheet.insert_chart("F2", chart)
  88. if __name__ == "__main__":
  89.     # 设置头部数据
  90.     headings = ["主机地址", "CPU内核态", "CPU用户态", "总利用率"]
  91.     head_style = workbook.add_format({"bold": True, "align": "center" ,"fg_color":"#D7E4BC"})
  92.     worksheet.write_row("A1", headings, head_style)
  94.     # 设置头部列宽
  95.     worksheet.set_column("A1:D1",15)
  97. # 统计数据并排序
  98.     cpu_data = []
  99.     with open("./unix_disk.db","r") as fp:
  100.         fp_file = fp.readlines()
  101.         for each in fp_file:
  102.             try:
  103.                 data = eval(each)
  104.                 ref = GetCPULoad(data[0], data[2], data[3], 22)
  105.                 if(len(ref) !=0):
  106.                     print(ref)
  107.                     cpu_data.append(ref)
  108.                 else:
  109.                     continue
  110.             except Exception:
  111.                 pass
  113.     # 排序,统计第三列数据，将最大的放在最前面，以此向下
  114.     cpu_data.sort(key=takeSecond, reverse=True)
  115.     print(cpu_data)
  117.     # 将数据批量添加到表格中
  118.     for i in range(0, len(cpu_data)):
  119.         worksheet.write_row("A{}".format(i + 2), cpu_data[i])
  121.     # 开始绘图
  122.     AddGraphical()
  123.     workbook.close()

收集主机负载（条形图)

制作Excel绘图：

  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook("xxx.xlsx")
  4. worksheet = workbook.add_worksheet()
  6. headings = ["获取时间", "1分钟负载", "5分钟负载","15分钟负载"]
  7. data = [["12:01", 0.05, 0.7,0.006], ["12:02", 0.5, 0.08,0.06], ["12:03", 0.7, 1,2.1]]
  9. # 定义表格样式
  10. head_style = workbook.add_format({"bold": True, "align": "center" ,"fg_color":"#D7E4BC"})
  11. worksheet.set_column("A1:D1",15)
  13. # 逐条写入数据
  14. worksheet.write_row("A1", headings, head_style)
  15. for i in range(0, len(data)):
  16.     worksheet.write_row("A{}".format(i + 2), data[i])
  18. # 添加条形图，显示前十个元素
  19. chart = workbook.add_chart({"type": "line"})
  20. chart.add_series({
  21.     "name": "=Sheet1!$B$1",              # 图例项
  22.     "categories": "=Sheet1!$A$2:$A$10",  # X轴 Item名称
  23.     "values": "=Sheet1!$B$2:$B$10"       # X轴Item值
  24. })
  25. chart.add_series({
  26.     "name": "=Sheet1!$C$1",
  27.     "categories": "=Sheet1!$A$2:$A$10",
  28.     "values": "=Sheet1!$C$2:$C$10"
  29. })
  30. chart.add_series({
  31.     "name": "=Sheet1!$D$1",
  32.     "categories": "=Sheet1!$A$2:$A$10",
  33.     "values": "=Sheet1!$D$2:$D$10"
  34. })
  36. # 添加柱状图标题
  37. chart.set_title({"name": "负载统计条形图"})
  38. # chart.set_style(8)
  40. chart.set_size({'width': 1000, 'height': 500})
  41. chart.set_legend({'position': 'top'})
  43. # 在F2处绘制
  44. worksheet.insert_chart("F2", chart)
  45. workbook.close()

封装SSH执行模块： 封装上方的绘图模块，与SSH模块实现图形绘制，收集十分钟负载。

  1. import xlsxwriter
  2. import paramiko
  3. import datetime
  4. import time
  6. ssh = paramiko.SSHClient()
  7. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  9. workbook = xlsxwriter.Workbook("load_avg.xlsx")
  10. worksheet = workbook.add_worksheet()
  12. def BatchCMD(address,username,password,port,command):
  13.     try:
  14.         ssh.connect(hostname=address,username=username,password=password,port=port,timeout=2)
  15.         stdin , stdout , stderr = ssh.exec_command(command)
  16.         result = stdout.read()
  17.         if len(result) != 0:
  18.             result = str(result).replace("\\n", "\n")
  19.             result = result.replace("b'", "").replace("'", "")
  20.             return result
  21.         else:
  22.             return None
  23.     except Exception:
  24.         return None
  26. def GetCPUAvg(address,username,password,port):
  27.     ref = []
  28.     cmd_dict = {"Linux\n" : "cat /proc/loadavg | awk '{print $1 \":\" $2 \":\" $3}'",
  29.                 "AIX\n" : "vmstat | tail -n 1 | awk '{print $14 \":\" $15 \":\" $16}'"
  30.                 }
  31.     os_version = BatchCMD(address,username,password,port,"uname")
  32.     for version,run_cmd in cmd_dict.items():
  33.         if(version == os_version):
  34.             os_ref = BatchCMD(address,username,password,port,run_cmd)
  35.             ref_list= os_ref.split("\n")
  36.             for each in ref_list:
  37.                 if each != "":
  38.                     ref = each.split(":")
  40.     str_to_date = datetime.datetime.now()
  41.     now_date = str(str_to_date.minute) + ":" + str(str_to_date.second)
  42.     ref.insert(0,now_date)
  43.     ref[1] = float(ref[1])
  44.     ref[2] = float(ref[2])
  45.     ref[3] = float(ref[3])
  46.     return ref
  48. # 绘制聚合图形
  49. def AddGraphical(data):
  50.     #data = [["12:01", 0.05, 0.7, 0.006], ["12:02", 0.5, 0.08, 0.06], ["12:03", 0.7, 1, 2.1]]
  52.     # 定义表格样式
  53.     head_style = workbook.add_format({"bold": True, "align": "center", "fg_color": "#D7E4BC"})
  54.     worksheet.set_column("A1:D1", 15)
  56.     # 逐条写入数据
  57.     headings = ["获取时间", "1分钟负载", "5分钟负载", "15分钟负载"]
  58.     worksheet.write_row("A1", headings, head_style)
  59.     for i in range(0, len(data)):
  60.         worksheet.write_row("A{}".format(i + 2), data[i])
  62.     # 添加条形图，显示前十个元素
  63.     chart = workbook.add_chart({"type": "line"})
  64.     chart.add_series({
  65.         "name": "=Sheet1!$B$1",  # 图例项
  66.         "categories": "=Sheet1!$A$2:$A$10",  # X轴 Item名称
  67.         "values": "=Sheet1!$B$2:$B$10"  # X轴Item值
  68.     })
  69.     chart.add_series({
  70.         "name": "=Sheet1!$C$1",  # 第一个线条（图例）
  71.         "categories": "=Sheet1!$A$2:$A$10",
  72.         "values": "=Sheet1!$C$2:$C$10"
  73.     })
  74.     chart.add_series({
  75.         "name": "=Sheet1!$D$1",  # 第二个线条（图例）
  76.         "categories": "=Sheet1!$A$2:$A$10",
  77.         "values": "=Sheet1!$D$2:$D$10"
  78.     })
  80.     # 添加柱状图标题
  81.     chart.set_title({"name": "负载统计条形图"})
  82.     # chart.set_style(8)
  84.     chart.set_size({'width': 900, 'height': 500})
  85.     chart.set_legend({'position': 'top'})
  87.     # 在F2处绘制
  88.     worksheet.insert_chart("F2", chart)
  90. # 收集10分钟的负载数据
  91. def GetLoad():
  92.     ref_date = []
  93.     for item in range(10):
  94.         ret = GetCPUAvg("192.168.1.11", "root", "123123", "22")
  95.         ref_date.append(ret)
  96.         time.sleep(60)
  97.         print(ret)
  98.     return ref_date
  100. if __name__ == "__main__":
  101.     date = []
  102.     date = GetLoad()
  103.     AddGraphical(date)
  104.     workbook.close()

绘制设备种类(饼状图)

制作Excel绘图： 先来实现绘图。

  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook("pie.xlsx")
  4. worksheet = workbook.add_worksheet()
  6. data = [["Suse", 30 ], ["Centos",25], ["AIX",15]]
  8. # 定义表格样式
  9. head_style = workbook.add_format({"bold": True, "align": "center" ,"fg_color":"#D7E4BC"})
  10. worksheet.set_column("A1:D1",15)
  12. # 逐条写入数据
  13. headings = ["系统版本", "数量"]
  14. worksheet.write_row("A1", headings, head_style)
  15. for i in range(0, len(data)):
  16.     worksheet.write_row("A{}".format(i + 2), data[i])
  18. # 添加条形图，显示前十个元素
  19. chart = workbook.add_chart({"type": "pie"})
  20. chart.add_series({
  21.     "name": "=Sheet1!$B$1",              # 图例项
  22.     "categories": "=Sheet1!$A$2:$A$4",  # X轴 Item名称
  23.     "values": "=Sheet1!$B$2:$B$4"       # X轴Item值
  24. })
  26. # 添加饼状图
  27. chart.set_title({"name": "系统版本分布"})
  28. chart.set_size({'width': 600, 'height': 300})
  29. chart.set_legend({'position': 'right'})
  31. # 在D2处绘制
  32. worksheet.insert_chart("D2", chart)
  33. workbook.close()

实现收集数据并绘图： 收集数据就不写了，主要说说统计个数，我们可以每次收集到数据后放入一个列表中，最后使用set集合将其自动去重，去重后在对特定的值进行计数统计即可。

  1. data = ["Windows 10","Windows 10","Windows 7","Windows 7","Suse","AIX","AIX"]
  2. dic = {}
  4. for each in set(data):
  5.     dic[each] = data.count(each)
  7. print(dic)

继续实现绘图即可。

  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook("pie.xlsx")
  4. worksheet = workbook.add_worksheet()
  6. # 去重后的数据在dic
  7. data = ["Windows 10","Windows 10","Windows 7","Windows 7","Suse","AIX","AIX"]
  8. dic = {}
  10. for each in set(data):
  11.     dic[each] = data.count(each)
  12. print("构建字典: {}".format(dic))
  13. print("字典数: {}".format(len(dic)))
  15. # 字典转列表
  16. new_data = []
  17. for k,v in dic.items():
  18.     new_list = [k,v]
  19.     new_data.append(new_list)
  20. print("字典转为列表：{}".format(new_data))
  22. #data = [["Suse", 30 ], ["Centos",25], ["AIX",15]]
  24. # 定义表格样式
  25. head_style = workbook.add_format({"bold": True, "align": "center" ,"fg_color":"#D7E4BC"})
  26. worksheet.set_column("A1:D1",15)
  28. # 逐条写入数据
  29. headings = ["系统版本", "数量"]
  30. worksheet.write_row("A1", headings, head_style)
  31. for i in range(0, len(new_data)):
  32.     worksheet.write_row("A{}".format(i + 2), new_data[i])
  34. # 添加饼状图图例
  35. chart = workbook.add_chart({"type": "pie"})
  36. chart.add_series({
  37.     "name": "=Sheet1!$B$1",              # 图例项
  38.     "categories": "=Sheet1!$A$2:$A${}".format(len(dic)+1),  # X轴 Item名称
  39.     "values": "=Sheet1!$B$2:$B${}".format(len(dic)+1)       # X轴Item值
  40. })
  42. # 添加饼状图
  43. chart.set_title({"name": "系统版本分布"})
  44. chart.set_size({'width': 600, 'height': 300})
  45. chart.set_legend({'position': 'right'})
  47. # 在D2处绘制
  48. worksheet.insert_chart("D2", chart)
  49. workbook.close()

Python 使用xlsxwriter绘制Excel表格的更多相关文章

  1. Python将多个excel表格合并为一个表格

    Python将多个excel表格合并为一个表格 生活中经常会碰到多个excel表格汇总成一个表格的情况,比如你发放了一份表格让班级所有同学填写,而你负责将大家的结果合并成一个.诸如此类的问题有很多.除 ...

  2. Python导出数据到Excel表格-NotImplementedError: formatting_info=True not yet implemented

    在使用Python写入数据到Excel表格中时出现报错信息记录:“NotImplementedError: formatting_info=True not yet implemented” 报错分析 ...

  3. Python 操作csv和excel表格

    1. 操作csv表格 使用的库 csv 1. csv文件里读取数据 代码 1. 以列表形式打开 import csv f = open('csv_test.csv', 'r') # 打开csv文件 c ...

  4. Python三个处理excel表格的库

    三个向excel表格写入数的库:xlwt,xlsxwriter,openpyxl,代码如下: 1 #第一个库,xlwt,不能写超过256列的表格 2 import xlwt 3 4 #新建workbo ...

  5. Python 使用openpyxl导出Excel表格的时候，使用save()保存到指定路径

    在使用openpyxl导出Excel表格的使用,如何指定导出的路径呢. 使用sava(filename),会保存到当前执行文件的路径下. 使用sava("/tmp/{}.xlsx" ...

  6. Python脚本：实现excel表格导入到数据库，支持mysql，postgresql，MongoDB

    import xlrd,re from datetime import datetime from xlrd import xldate_as_tuple # 判断上传表格是否与模板要求一致 def ...

  7. Python利用xlutils统计excel表格数据

    假设有像上这样一个表格,里面装满了各式各样的数据,现在要利用模板对它进行统计每个销售商的一些数据的总和.模板如下: 代码开始: 1 #!usr/bin/python3 2 # -*-coding=ut ...

  8. python XlsxWriter创建Excel 表格

    文档(英文) https://xlsxwriter.readthedocs.io/index.html 常用模块说明(中文) https://blog.csdn.net/sinat_35930259/ ...

  9. Python使用openpyxl操作excel表格

    前言 本文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理. PS:如有需要Python学习资料的小伙伴可以加点击下方链接自行获取 ht ...

随机推荐

  1. 一个页面中多个window.onload = function(){}冲突问题解决思路

    转: 一个页面中多个window.onload = function(){}冲突问题解决思路 一个页面中多个window.onload = function(){}冲突问题解决思路 参考文章: (1) ...

  2. SQL-MYSQL的时间格式转换（持续补充）

    ======================SQLSERVER===================================== SELECT CONVERT(varchar(100), GE ...

  3. 2020 年安装 FreeBSD 系统的基础视频

    B 站搜索 BV14i4y137mh 包含了下载,虚拟机安装,配置 SSH 等教程. https://www.bilibili.com/video/BV14i4y137mh

  4. Codeforces Round #574 (Div. 2) D2. Submarine in the Rybinsk Sea (hard edition) 【计算贡献】

    一.题目 D2. Submarine in the Rybinsk Sea (hard edition) 二.分析 相比于简单版本,它的复杂地方在于对于不同长度,可能对每个点的贡献可能是有差异的. 但 ...

  5. SpringBoot自动配置探究

    @SpringBootApplication @SpringBootApplication表示SpringBoot应用,标注在某个类上说明这个类是SpringBoot的主配置类,SpringBoot就 ...

  6. Linux系统（Centos7）最新版本Docker简易（yum）安装步骤

    Docker从1.13版本之后采用时间线的方式作为版本号,分为社区版CE和企业版EE. 社区版是免费提供给个人开发者和小型团体使用的,企业版会提供额外的收费服务,比如经过官方测试认证过的基础设施.容器 ...

  7. 一种3位sar adc仿真验证

    3位sar adc采用下图的电容阵列,电路如下图:所有电容的正端(也称为上极板)与比较器的同相端连接,比较器反相端接gnd,其工作过程进行大致分析见之前的文章<一种3位sar adc工作过程推导 ...

  8. Java 给PPT添加动画效果（预设动画/自定义动画）

    PPT幻灯片中对形状可设置动画效果,常见的动画效果为内置的固定类型,即动画效果和路径是预先设定好的固定模板,但在设计动画效果时,用户也可以按照自己的喜好自定义动画动作路径.下面,通过Java后端程序代 ...

  9. python那些需要知道的事儿——逻辑运算与比大小

    一.逻辑运算 逻辑运算符: and   or   not,结果为布尔值(True和False) 1.基本逻辑运算符介绍 not :将后面的逻辑运算结果取反 >>> not 1 < ...

  10. [Azure Devops] 使用 Azure Repos 管理代码

    1. 什么是 Azure Repos Azure Repos 是一组版本控制工具,可用于管理代码.无论您的软件项目是大型项目还是小型项目,都应尽快使用版本控制. 版本控制系统是可帮助您跟踪随时间变化对 ...