发帖
翼度科技»论坛 › 编程开发 › python › 查看内容

Python 使用XlsxWriter操作Excel

云少春

6

主题

6

帖子

18

积分

新手上路

Rank: 1

积分
18
显示全部楼层
在数据处理和报告生成的领域中，Excel 文件一直是广泛使用的标准格式。为了让 Python 开发者能够轻松创建和修改 Excel 文件，XlsxWriter 库应运而生。XlsxWriter 是一个功能强大的 Python 模块，专门用于生成 Microsoft Excel 2007及以上版本（.xlsx 格式）的电子表格文件。本文将对XlsxWriter进行概述，探讨其主要特点、用法和一些实际应用，并实现绘制各类图例（条形图，柱状图，饼状图）等。
主要特点


  • .xlsx 格式支持： XlsxWriter 专注于创建 Microsoft Excel 2007 及以上版本的文件，这是一种基于 XML 的格式，允许存储大量数据、样式和图表。
  • 格式和样式： XlsxWriter 允许开发者以编程方式设置单元格的格式和样式，包括字体、颜色、对齐方式等。这使得生成的 Excel 文件能够呈现出精美的外观。
  • 图表和图形： XlsxWriter 支持创建各种类型的图表，如折线图、柱状图、饼图等，使用户能够直观地呈现数据。同时，它还支持插入图片、形状和注释等图形元素。
  • 公式和函数： XlsxWriter 允许在单元格中使用 Excel 公式和函数，这对于进行复杂的计算和数据分析非常有用。
  • 大数据量处理： XlsxWriter 被设计为高性能的库，能够处理大规模的数据集，同时保持生成的 Excel 文件的高质量。
  • 图表和条件格式： 除了基本的单元格样式，XlsxWriter 支持添加条件格式，以及在工作表中插入图表，提供更直观的数据可视化。
安装模块

要开始使用 XlsxWriter，首先需要安装该库。可以通过以下命令使用 pip 安装：
  1. pip install XlsxWriter
复制代码
XlsxWriter 提供了一个强大而灵活的工具，使得使用 Python 生成 Excel 文件变得简单而高效。无论是用于数据分析、报告生成还是其他领域，XlsxWriter 都为开发者提供了一种简单而可靠的方法，使他们能够充分利用 Excel 的强大功能。在掌握了基本用法后，开发者可以深入研究 XlsxWriter 的高级特性，以满足更复杂的需求。
单行输出函数

函数WriteSingleArticle()调用时传入文档名称，以及传入表头和数据，写出简单的单行记录。
  1. import xlsxwriter
  3. # 写出数据
  4. def WriteSingleArticle(xls_name,header,data):
  5.     workbook = xlsxwriter.Workbook(xls_name)
  6.     worksheet = workbook.add_worksheet()
  8.     # 定义表格样式
  9.     head_style = workbook.add_format({"bold": True, "align": "center", "border": 1, "fg_color": "#D7E4BC"})
  10.     worksheet.set_column("A1:D1", 15)
  12.     # 写出表头
  13.     worksheet.write_row("A1", header, head_style)
  14.     for index in range(0, len(data)):
  15.         worksheet.write_row("A{}".format(index + 2), data[index])
  17.     workbook.close()
  18.     return True
  20. if __name__ == "__main__":
  21.     headings = ["用户名", "密码", "地址"]
  22.     data = [["admin","123456","192.168.1.1"],["admin","123456","192.168.1.1"]]
  24.     ref = WriteSingleArticle("lyshark.xlsx",headings,data)
  25.     print("写出状态: {}".format(ref))
复制代码
输出效果如下所示；

多行表格输出函数

函数CreateTable(address,data,section)实现了输出一个列表格式的Table，只需传入列表序列即可。
先找到表格生成坐标与大小之间的比值关系，这是第一步，如下是简单的实现固定位置生成表格。
  1. import xlsxwriter
  3. # 设置表格sheet名称
  4. workbook = xlsxwriter.Workbook('lyshark.xlsx')
  5. worksheet = workbook.add_worksheet("系统磁盘统计")
  7. # 设置头部标题IP地址列
  8. merge_format = workbook.add_format({'bold': True,'border': 1,'align': 'center','valign': 'vcenter','fg_color': '#EEAEEE'})
  9. worksheet.merge_range('A9:B12', '192.168.1.1', merge_format)
  11. # 设置表格头部提示,并将前两个表头合并为1个
  12. header = ["IP地址","IP地址","路径","总容量","剩余容量","利用率"]
  13. merge_format1 = workbook.add_format({'bold': True,'border': 1,'align': 'center','valign': 'vcenter','fg_color': '#AEEEEE'})
  14. worksheet.write_row("A8:B12",header,merge_format1)        # 显示表头
  15. worksheet.merge_range('A8:B8',"IP地址",merge_format1)      # 合并表头(合并第一个元素)
  17. # 写出路径列表
  18. data1 = ["/etc/system/","/proc/","/sys","/var/lyshark"]
  19. merge_format2 = workbook.add_format({'bold': True,'border': 1,'valign': 'vcenter','fg_color': '#D7E4BC','align': 'center'})
  20. worksheet.write_column("C9",data1,merge_format2)
  21. worksheet.set_column("C9:C9",30)
  23. # 写出总容量
  24. data2 = ["1024 GB","2048 GB","111 GB","1111 GB"]
  25. merge_format3 = workbook.add_format({'bold': True,'border': 1,'valign': 'vcenter','fg_color': '#D7E4BC','align': 'center'})
  26. worksheet.write_column("D9",data2,merge_format3)
  27. worksheet.set_column("D9:D9",20)
  29. # 写出剩余容量
  30. data3 = ["1024 GB","2048 GB","111 GB","22 GB"]
  31. merge_format4 = workbook.add_format({'bold': True,'border': 1,'valign': 'vcenter','fg_color': '#D7E4BC','align': 'center'})
  32. worksheet.write_column("E9",data3,merge_format4)
  33. worksheet.set_column("E9:E9",20)
  35. # 写出利用率
  36. data4= ["10%","50%","20%","33%"]
  37. merge_format5 = workbook.add_format({'bold': True,'border': 1,'valign': 'vcenter','fg_color': '#D7E4BC','align': 'center'})
  38. worksheet.write_column("F9",data4,merge_format5)
  39. worksheet.set_column("F9:F9",20)
  41. workbook.close()
复制代码
输出效果如下所示；

继续封装如上代码，将其封装为CreateTable(address,data,section)函数，用户传入表头地址，数据集，以及从第几行开始写数据，则自动生成表单。
  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook('lyshark.xlsx')
  4. worksheet = workbook.add_worksheet("统计表")
  6. # 创建表结构
  7. def CreateTable(address,data,section):
  8.     # --------------------------------------------------------------------
  9.     # 计算表头列表长度
  10.     header_count = len(data[1])
  11.     print("不带表头的列表长度: {}".format(header_count))
  13.     merge_format1 = workbook.add_format({'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#AEEEEE'})
  14.     # 根据表格列长度 计算出表格大小
  15.     header_range = f"A{section}:B{section+header_count}"
  16.     print("表头总长度 header_range = {}".format(header_range))
  17.     # 写出表头到文件
  18.     worksheet.write_row(header_range, data[0], merge_format1)
  20.     # --------------------------------------------------------------------
  21.     # 计算合并表头偏移,并合并
  22.     header_merge_range = f"A{section}:B{section}"
  23.     print("合并表头偏移 header_merge_range = {}".format(header_merge_range))
  25.     # 合并表头(合并第一个元素)
  26.     header_table = data[0][0]
  27.     worksheet.merge_range(header_merge_range, header_table, merge_format1)
  28.     # worksheet.merge_range(header_merge_range, "IP地址", merge_format1)
  30.     # --------------------------------------------------------------------
  31.     # 计算出表头 所占总单元格大小
  32.     remove_header_count = len(data) - 1
  33.     print("除去表头的列表长度: {}".format(remove_header_count))
  34.     # 此处自己调整列长度
  35.     address_merge_range = f"A{section+1}:B{section  + len(data[0][1])}"
  36.     print("所占总单元格大小 address_merge_range = {} => {}".format(len(data[0][1]),address_merge_range))
  38.     merge_format = workbook.add_format({'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#EEAEEE'})
  40.     # 写出单元格合并大小
  41.     worksheet.merge_range(address_merge_range, address , merge_format)
  43.     # --------------------------------------------------------------------
  44.     # 循环填充数据
  45.     merge_format_index = workbook.add_format(
  46.         {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  48.     letter_list = ['C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  49.                    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
  51.     # 循环填充数据 最大字段长度为24
  52.     for index in range(0, remove_header_count):
  53.         index_range = f"{letter_list[index]}{section+1}"
  54.         worksheet.write_column(index_range, data[index+1], merge_format_index)
  56.         index_range = f"{letter_list[index]}{section+1}:{letter_list[index]}{section+1}"
  57.         worksheet.set_column(index_range, 30)
  59.     """
  60.         #  不使用循环逐条填充
  61.         merge_format2 = workbook.add_format( {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  63.         index_range = "C{}".format(section+1)
  64.         worksheet.write_column(index_range, data[1], merge_format2)
  65.         index_range = "C{}:C{}".format(section+1,section+1)
  66.         worksheet.set_column(index_range, 30)
  68.         index_range = "D{}".format(section+1)
  69.         worksheet.write_column(index_range, data[2], merge_format2)
  70.         index_range = "D{}:D{}".format(section+1,section+1)
  71.         worksheet.set_column(index_range, 30)
  73.         index_range = "E{}".format(section+1)
  74.         worksheet.write_column(index_range, data[2], merge_format2)
  75.         index_range = "E{}:E{}".format(section+1,section+1)
  76.         worksheet.set_column(index_range, 30)
  77.     """
  78.     # 返回计算后的表格的下两个单元的实际偏移位置
  79.     return section + remove_header_count + 3
  81. # 测试恒矩阵
  82. def Test():
  83.     val = \
  84.     [
  85.         ["测试地址", "测试地址","磁盘路径", "总容量", "剩余容量"],
  86.         ["/etc/system/", "/proc/", "/sys", "/user"],
  87.         ["1024 GB", "2048 GB", "12 GB","98 GB"],
  88.         ["1345 GB", "1124 GB", "341 GB", "55 GB"]
  89.     ]
  91.     ref = CreateTable("192.168.1.1",val,1)
  92.     print("返回下一个表格索引: {}".format(ref))
  94.     ref = CreateTable("192.168.1.1",val,ref)
  95.     print("返回下一个表格索引: {}".format(ref))
  97.     workbook.close()
  99. # 测试竖矩阵
  100. def Test2():
  102.     header = ["测试地址", "测试地址","磁盘路径", "总容量", "剩余容量"]
  104.     val = \
  105.     [
  106.         ["/etc/system/", "1024 GB", "256 GB"],
  107.         ["/etc/passwd/", "104 GB", "345GB"],
  108.         ["/etc/username/", "12 GB", "56 GB"],
  109.         ["/etc/lyshark/", "12 GB", "56 GB"]
  110.     ]
  112.     # 横向矩阵转竖向矩阵
  113.     ref_xor = list ( map(list,zip(*val)) )
  115.     # 追加头部
  116.     ref_xor.insert(0, header)
  117.     print(ref_xor)
  119.     ref = CreateTable("192.168.1.1",ref_xor,1)
  120.     print("返回下一个表格索引: {}".format(ref))
  122.     workbook.close()
  124. if __name__ == "__main__":
  125.     Test2()
复制代码
输出效果如下所示；

柱状图输出函数

简单实现CreateChart(headings,data)柱状图生成函数，通过传入头部标题和数据集列表即可完成表单生成。
  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook('lyshark.xlsx')
  4. worksheet = workbook.add_worksheet("统计表")
  6. def CreateChart(headings,data):
  7.     # 定义表格样式
  8.     head_style = workbook.add_format({"bold": True, "align": "center", "font": 13})
  10.     # 逐条写入数据
  11.     worksheet.write_row("A1", headings, head_style)
  12.     for i in range(0, len(data)):
  13.         worksheet.write_row("A{}".format(i + 2), data[i])
  15.     # 添加柱状图
  16.     chart = workbook.add_chart({"type": "column"})
  17.     chart.add_series({
  18.         "name": "=统计表!$B$1",              # 图例项
  19.         "categories": "=统计表!$A$2:$A$10",  # X轴Item名称
  20.         "values": "=统计表!$B$2:$B$10"       # X轴Item值
  21.     })
  22.     chart.add_series({
  23.         "name": "=统计表!$C$1",
  24.         "categories": "=统计表!$A$2:$A$10",
  25.         "values": "=统计表!$C$2:$C$10"
  26.     })
  27.     chart.add_series({
  28.         "name": "=统计表!$D$1",
  29.         "categories": "=统计表!$A$2:$A$10",
  30.         "values": "=统计表!$D$2:$D$10"
  31.     })
  33.     # 添加柱状图标题
  34.     chart.set_title({"name": "性能统计柱状图"})
  35.     chart.set_style(12)
  37.     # 在G2处绘制
  38.     worksheet.insert_chart("G2", chart)
  39.     workbook.close()
  41. if __name__ == "__main__":
  42.     headings = ["主机地址", "CPU利用率", "内存利用率", "交换分区"]
  43.     data = [["192.168.1.100", 88, 36, 66], ["192.168.1.200", 98, 89, 66], ["192.168.1.220", 88, 100, 32]]
  45.     # 循环添加模拟数据
  46.     for i in range(1, 100):
  47.         s = ["192.168.1.{}".format(i), i, i, i]
  48.         data.append(s)
  50.     CreateChart(headings,data)
复制代码
输出效果如下所示；

条形图输出函数

封装CreateChart(headings,data)函数实现输出条形图，并将前十的数据绘成图展示在右侧。
  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook('lyshark.xlsx')
  4. worksheet = workbook.add_worksheet("统计表")
  6. def CreateChart(headings,data):
  7.     # 定义表格样式
  8.     head_style = workbook.add_format({"bold": True, "align": "center", "fg_color": "#D7E4BC"})
  9.     worksheet.set_column("A1:D1", 15)
  11.     # 逐条写入数据
  12.     worksheet.write_row("A1", headings, head_style)
  13.     for i in range(0, len(data)):
  14.         worksheet.write_row("A{}".format(i + 2), data[i])
  16.     # 添加条形图，显示前十个元素
  17.     chart = workbook.add_chart({"type": "line"})
  18.     chart.add_series({
  19.         "name": "=统计表!$B$1",              # 图例项
  20.         "categories": "=统计表!$A$2:$A$10",  # X轴Item名称
  21.         "values": "=统计表!$B$2:$B$10"       # X轴Item值
  22.     })
  23.     chart.add_series({
  24.         "name": "=统计表!$C$1",
  25.         "categories": "=统计表!$A$2:$A$10",
  26.         "values": "=统计表!$C$2:$C$10"
  27.     })
  28.     chart.add_series({
  29.         "name": "=统计表!$D$1",
  30.         "categories": "=统计表!$A$2:$A$10",
  31.         "values": "=统计表!$D$2:$D$10"
  32.     })
  34.     # 添加柱状图标题
  35.     chart.set_title({"name": "负载统计条形图"})
  36.     # chart.set_style(8)
  38.     chart.set_size({'width': 1000, 'height': 500})
  39.     chart.set_legend({'position': 'top'})
  41.     # 在F2处绘制
  42.     worksheet.insert_chart("F2", chart)
  43.     workbook.close()
  45. if __name__ == "__main__":
  46.     headings = ["获取时间", "1分钟负载", "5分钟负载", "15分钟负载"]
  47.     data = [["12:01", 0.05, 0.7, 0.006], ["12:02", 0.5, 0.08, 0.06], ["12:03", 0.7, 1, 2.1]]
  48.     CreateChart(headings,data)
复制代码
输出效果如下所示；

饼状图输出函数

函数CreateChart(headings,data)用于生成饼状图，实现对主机以及主机数量的图形化展示。
  1. import xlsxwriter
  3. workbook = xlsxwriter.Workbook('lyshark.xlsx')
  4. worksheet = workbook.add_worksheet("统计表")
  6. def CreateChart(headings,data):
  7.     # 定义表格样式
  8.     head_style = workbook.add_format({"bold": True, "align": "center", "fg_color": "#D7E4BC"})
  9.     worksheet.set_column("A1:D1", 15)
  11.     # 逐条写入数据
  12.     worksheet.write_row("A1", headings, head_style)
  13.     for i in range(0, len(data)):
  14.         worksheet.write_row("A{}".format(i + 2), data[i])
  16.     # 添加条形图，显示前十个元素
  17.     chart = workbook.add_chart({"type": "pie"})
  18.     chart.add_series({
  19.         "name": "=统计表!$B$1",             # 图例项
  20.         "categories": "=统计表!$A$2:$A$4",  # X轴 Item名称
  21.         "values": "=统计表!$B$2:$B$4"       # X轴Item值
  22.     })
  24.     # 添加饼状图
  25.     chart.set_title({"name": "系统版本分布"})
  26.     chart.set_size({'width': 600, 'height': 300})
  27.     chart.set_legend({'position': 'right'})
  29.     # 在D2处绘制
  30.     worksheet.insert_chart("D2", chart)
  31.     workbook.close()
  33. if __name__ == "__main__":
  34.     headings = ["系统版本", "数量"]
  35.     data = [["Suse", 30], ["Centos", 25], ["AIX", 15]]
  36.     CreateChart(headings,data)
复制代码
输出效果如下所示；

实现绘图类

通过调用xlsxwriter第三方库,实现绘制各类通用图形,并保存为XLS文档格式.
  1. import xlsxwriter
  3. class DrawChart():
  4.     def __init__(self,workbook):
  5.         self.workbook = xlsxwriter.Workbook(workbook)
  7.     # 排序函数,以第三列为条件排列
  8.     def cpu_takeSecond(self,elem):
  9.         return int(elem[3])
  10.     def mem_taskSecond(self,elem):
  11.         return int(elem[1])
  13.     # 封装统计主机磁盘使用情况
  14.     def CreateDiskTable(self,worksheet,address,data,section):
  15.         # 添加统计名称 例如: 磁盘统计
  16.         worksheet = self.workbook.add_worksheet(worksheet)
  17.         merge_format = self.workbook.add_format(
  18.             {'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#EEAEEE'})
  20.         header_count = len(data[1])
  21.         merge_format1 = self.workbook.add_format(
  22.             {'bold': True, 'border': 1, 'align': 'center', 'valign': 'vcenter', 'fg_color': '#AEEEEE'})
  24.         # 根据磁盘路径计算出表格大小
  25.         header_range = "A{}:B{}".format(section,section+header_count)
  26.         worksheet.write_row(header_range, data[0], merge_format1)  # 显示表头
  28.         # 计算合并表头偏移
  29.         header_merge_range = "A{}:B{}".format(section,section)
  30.         worksheet.merge_range(header_merge_range, "巡检IP地址", merge_format1)  # 合并表头(合并第一个元素)
  32.         # 计算出地址所占总单元格大小
  33.         address_merge_range = "A{}:B{}".format(section+1,section+header_count)
  34.         worksheet.merge_range(address_merge_range, address , merge_format)  #需要计算出来，根据传入分区数量
  36.         # 通过计算得到磁盘路径所对应到表中的位置
  37.         merge_format2 = self.workbook.add_format(
  38.             {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC'})
  40.         index_range = "C{}".format(section+1)
  41.         worksheet.write_column(index_range, data[1], merge_format2)
  42.         index_range = "C{}:C{}".format(section+1,section+1)
  43.         worksheet.set_column(index_range, 30)
  45.         # 计算出总容量对应到表中的位置
  46.         merge_format3 = self.workbook.add_format(
  47.             {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  49.         index_range = "D{}".format(section + 1)
  50.         worksheet.write_column(index_range, data[2], merge_format3)
  52.         index_range = "D{}:D{}".format(section + 1, section + 1)
  53.         worksheet.set_column(index_range, 20)
  55.         # 计算出剩余容量对应到表中的位置
  56.         merge_format4 = self.workbook.add_format(
  57.             {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  58.         index_range = "E{}".format(section + 1)
  59.         worksheet.write_column(index_range, data[3], merge_format4)
  60.         index_range = "E{}:E{}".format(section + 1, section + 1)
  61.         worksheet.set_column(index_range, 20)
  63.         # 计算出利用率对应到表中的位置
  64.         merge_format5 = self.workbook.add_format(
  65.             {'bold': True, 'border': 1, 'valign': 'vcenter', 'fg_color': '#D7E4BC', 'align': 'center'})
  67.         index_range = "F{}".format(section + 1)
  68.         worksheet.write_column(index_range, data[4], merge_format5)
  69.         index_range = "F{}:F{}".format(section + 1, section + 1)
  70.         worksheet.set_column(index_range, 20)
  72.         # 返回计算后的表格的下两个单元的实际偏移位置
  73.         return section + header_count + 3
  75.     # 创建CPU利用率百分比,并统计前十
  76.     def CreateCpuUsedTable(self,worksheet,header,data):
  77.         worksheet = self.workbook.add_worksheet(worksheet)
  79.         # 设置头部颜色,并写入头部数据
  80.         head_style = self.workbook.add_format({"bold": True, "align": "center", "fg_color": "#D7E4BC"})
  81.         worksheet.write_row("A1", header, head_style)
  83.         # 设置头部列宽
  84.         worksheet.set_column("A1:D1", 15)
  86.         # 排序,统计第三列数据，将最大的放在最前面，以此向下
  87.         data.sort(key=self.cpu_takeSecond, reverse=True)
  89.         # 将数据批量添加到表格中
  90.         for x in range(0,len(data)):
  91.             worksheet.write_row("A{}".format(x + 2), data[x])
  93.         # --------------------------------------------------------------
  94.         # 添加柱状图(开始绘图)
  95.         chart = self.workbook.add_chart({"type": "column"})
  96.         chart.add_series({
  97.             "name": "=CPU利用率!$B$1",              # 图例项(也就是CPU内核态)
  98.             "categories": "=CPU利用率!$A$2:$A$10",  # X轴 Item名称
  99.             "values": "=CPU利用率!$B$2:$B$10"       # X轴Item值
  100.         })
  101.         chart.add_series({
  102.             "name": "=CPU利用率!$C$1",
  103.             "categories": "=CPU利用率!$A$2:$A$10",
  104.             "values": "=CPU利用率!$C$2:$C$10"
  105.         })
  106.         chart.add_series({
  107.             "name": "=CPU利用率!$D$1",
  108.             "categories": "=CPU利用率!$A$2:$A$10",
  109.             "values": "=CPU利用率!$D$2:$D$10"
  110.         })
  112.         # 添加柱状图标题
  113.         chart.set_title({"name": "CPU 性能统计柱状图"})
  114.         # chart.set_style(8)
  116.         chart.set_x_axis({
  117.             'major_gridlines': {
  118.                 'visible': True,
  119.                 'line': {'width': 1.25, 'dash_type': 'dash'}
  120.             },
  121.         })
  123.         chart.set_size({'width': 900, 'height': 500})
  124.         chart.set_legend({'position': 'top'})
  125.         chart.set_table({'show_keys': True})
  127.         # 在F2处绘制
  128.         worksheet.insert_chart("F2", chart)
  130.     # 内存利用率统计
  131.     def CreateMemoryTable(self, worksheet, header, data):
  132.         worksheet = self.workbook.add_worksheet(worksheet)
  134.         # 设置头部颜色,并写入头部数据
  135.         head_style = self.workbook.add_format({"bold": True, "align": "center", "fg_color": "#D7E4BC"})
  136.         worksheet.write_row("A1", header, head_style)
  138.         # 设置头部列宽
  139.         worksheet.set_column("A1:D1", 15)
  141.         # 排序,统计第三列数据，将最大的放在最前面，以此向下
  142.         data.sort(key=self.mem_taskSecond, reverse=True)
  144.         # 将数据批量添加到表格中
  145.         for x in range(0,len(data)):
  146.             worksheet.write_row("A{}".format(x + 2), data[x])
  148.         # --------------------------------------------------------------
  149.         # 添加柱状图(横向图)
  150.         chart = self.workbook.add_chart({"type": "bar"})
  151.         chart.add_series({
  152.             "name": "=内存利用率!$B$1",
  153.             "categories": "=内存利用率!$A$2:$A$10",
  154.             "values": "=内存利用率!$B$2:$B$10"
  155.         })
  156.         chart.add_series({
  157.             "name": "=内存利用率!$C$1",
  158.             "categories": "=内存利用率!$A$2:$A$10",
  159.             "values": "=内存利用率!$C$2:$C$10"
  160.         })
  161.         # 添加柱状图标题
  162.         chart.set_title({"name": "内存利用率统计图"})
  163.         chart.set_x_axis({
  164.             'major_gridlines': {
  165.                 'visible': True,
  166.                 'line': {'width': 1.25, 'dash_type': 'dash'}
  167.             },
  168.         })
  169.         chart.set_size({'width': 900, 'height': 400})
  170.         chart.set_legend({'position': 'top'})
  171.         # 在F2处绘制
  172.         worksheet.insert_chart("F2", chart)
  174.     # --------------------------------------------------------------
  175.     # 统计CPU Load 负载情况 注意: 只能指定单独的主机
  176.     def CreateCpuLoadAvgTable(self, address,worksheet, header, data):
  177.         worksheet = self.workbook.add_worksheet(worksheet)
  179.         # 设置头部颜色,并写入头部数据
  180.         head_style = self.workbook.add_format({"bold": True, "align": "center", "fg_color": "#D7E4BC"})
  181.         worksheet.write_row("A1", header, head_style)
  183.         # 设置头部列宽
  184.         worksheet.set_column("A1:D1", 15)
  186.         # 将数据批量添加到表格中
  187.         for x in range(0,len(data)):
  188.             worksheet.write_row("A{}".format(x + 2), data[x])
  190.         # 定义表格样式
  191.         head_style = self.workbook.add_format({"bold": True, "align": "center", "fg_color": "#D7E4BC"})
  192.         worksheet.set_column("A1:D1", 15)
  194.         # 逐条写入数据
  195.         worksheet.write_row("A1", header, head_style)
  196.         for i in range(0, len(data)):
  197.             worksheet.write_row("A{}".format(i + 2), data[i])
  199.         # 添加条形图，显示前十个元素
  200.         chart = self.workbook.add_chart({"type": "line"})
  201.         chart.add_series({
  202.             "name": "=CPU负载数据统计!$B$1",  # 图例项
  203.             "categories": "=CPU负载数据统计!$A$2:$A$10",  # X轴 Item名称
  204.             "values": "=CPU负载数据统计!$B$2:$B$10"  # X轴Item值
  205.         })
  206.         chart.add_series({
  207.             "name": "=CPU负载数据统计!$C$1",  # 第一个线条（图例）
  208.             "categories": "=CPU负载数据统计!$A$2:$A$10",
  209.             "values": "=CPU负载数据统计!$C$2:$C$10"
  210.         })
  211.         chart.add_series({
  212.             "name": "=CPU负载数据统计!$D$1",  # 第二个线条（图例）
  213.             "categories": "=CPU负载数据统计!$A$2:$A$10",
  214.             "values": "=CPU负载数据统计!$D$2:$D$10"
  215.         })
  217.         # 添加柱状图标题
  218.         chart.set_title({"name": "统计地址: {}".format(address)})
  219.         chart.set_size({'width': 900, 'height': 500})
  220.         chart.set_legend({'position': 'top'})
  222.         # 在F2处绘制
  223.         worksheet.insert_chart("F2", chart)
  225.     # 关闭并保存绘制结果
  226.     def Save(self):
  227.         self.workbook.close()
  229. if __name__ == "__main__":
  230.     work = DrawChart("lyshark.xlsx")
  231.     # ------------------------------------------------------------------
  232.     # 统计系统磁盘容量
  233.     disk_val = [
  234.         ["IP地址", "IP地址", "磁盘路径", "总容量", "剩余容量", "利用率"],
  235.         ["/etc/system/", "/proc/", "/sys", "/abc/lyshark"],
  236.         ["1024GG", "2048GB", "111GB", "1111GB"],
  237.         ["1024GG", "2048GB", "111GB", "22GB"],
  238.         ["10%", "50%", "20%", "33%"]
  239.     ]
  240.     ref = work.CreateDiskTable("磁盘分区统计","127.0.0.1",disk_val,3)
  241.     print("下个表格开头位置: {}".format(ref))
  242.     print("[+] 磁盘数据统计完成")
  244.     # -------------------------------------------------------------------
  245.     # 统计系统CPU负载情况
  246.     header = ["主机地址", "CPU内核态", "CPU用户态", "总利用率"]
  247.     cpu_val = [
  248.         ["192.168.1.100", 88, 36, 100],
  249.         ["192.168.1.200", 98, 89, 128],
  250.         ["192.168.1.220", 88, 100, 190]
  251.     ]
  252.     ref = work.CreateCpuUsedTable("CPU利用率",header,cpu_val)
  253.     print("[+] CPU利用率统计已完成")
  255.     # -------------------------------------------------------------------
  256.     # 统计系统内存利用率数据
  257.     header = ["主机地址", "通用内存利用率", "交换内存利用率"]
  258.     mem_val = [
  259.         ["192.168.1.100", 25, 35],
  260.         ["192.168.1.200", 44, 57],
  261.         ["192.168.1.200", 24, 21],
  262.         ["192.168.1.200", 78, 89]
  263.     ]
  264.     ref = work.CreateMemoryTable("内存利用率",header,mem_val)
  265.     print("[+] 内存利用率统计已完成")
  267.     # -------------------------------------------------------------------
  268.     # 获取CPU LoadAvg负载情况
  269.     header = ["拉取日期","1分钟负载","5分钟负载","15分钟负载"]
  270.     cpu_avg_val = [
  271.         ["12:11",0.1,0.2,1.3],
  272.         ["12:12",1.4,3.3,6.9],
  273.         ["12:13",2.6,3.2,6.9]
  274.     ]
  275.     ref = work.CreateCpuLoadAvgTable("127.0.0.1","CPU负载数据统计",header,cpu_avg_val)
  276.     print("[+] CPU负载统计完成")
  277.     work.Save()
复制代码
输出效果如下所示；


来源:https://www.cnblogs.com/LyShark/p/17851542.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x

上一篇: Python 使用XlsxWriter操作Excel

下一篇: 简单的用Python采集股票数据，保存表格后分析历史数据

发表于 2023-11-23 14:55:28

举报 回复 使用道具

返回列表 发新帖

Archiver|手机版|小黑屋|翼度科技

Copyright © 2001-2020, Tencent Cloud.　Powered by Discuz! X3.4