Python使用xlwt构建Excel报表：模板策略与字典数据聚合实战

Evan

发布时间：2026-10-13| 2人浏览过

原创

本文深入解析Python使用xlwt库生成Excel报表的两种核心策略：动态创建模板与预存模板文件的性能权衡。重点阐述如何通过Python字典（Dict）结构，将来自不同SQL查询的成交量、下单量及失败量等多源数据，按游戏名称进行键值聚合与对齐。通过示例代码展示如何处理数据缺失、排序不一致及多字段键合并拆分问题，实现高效且准确的数据写入。

本文主要探讨利用Python语言结合Map（字典）结构生成Excel报表的实现方案，具体代码与逻辑如下。

前言：目前我们已能熟练编写处理Excel的脚本。常规流程通常包括：从数据库提取数据、构建Excel模板、基于模板生成新文件并将数据库数据写入，最后发送邮件。之前的博客已详细记录了标准流程，此处我们将聚焦于实践中遇到的新问题进行讨论。

在以往编写此类脚本时，有一个问题常被忽略：为何必须先建立模板再写入数据？并非未曾思考，而是出于效率考量，往往浅尝辄止，只求快速完成任务。

本文旨在对这一环节进行深入的思考与阐述。

【为什么要建立Excel表模板？】

建立Excel模板通常与历史数据的管理需求相关，其必要性在于以下场景。

假设我们需要一份月度数据表，每天生成一行记录。到了下个月，则需要创建一个新的月份表格。

在后续进行数据统计时，只需获取每个月最后一天的数据表即可，因为该表格包含了当月所有的累计数据。

针对此类需求，脚本代码在月份更替时，必须创建新表，而不应继续复用旧表作为模板进行写入。

显然，新月的表格不能继承上月数据，因此必须重新书写表头。

深入思考此过程，会引出另一个关键问题。

【建立Excel模板的方法的本质】

def createTemplateExcel():
 '''创建Excel文件模板'''
 wb = xlwt.Workbook(encoding = "UTF-8", style_compression = True)
 sht0 = wb.add_sheet("线上", cell_overwrite_ok = True)
 sht0.col(0).width=4000
 sht0.write(0, 0, '游戏名称', style1)
 sht0.write(0, 1, '渠道', style1)
 sht0.write(0, 2, '成交量', style1)
 sht0.write(0, 3, '下单量', style1)
 sht0.write(0, 4, '失败量', style1)

 sht1 = wb.add_sheet("线下", cell_overwrite_ok = True)
 sht1.col(0).width=4000
 sht1.write(0, 0, '游戏名称', style1)
 sht1.write(0, 1, '成交量', style1)
 sht1.write(0, 2, '下单量', style1)
 sht1.write(0, 3, '失败量', style1)
 return wb
 或者
 wb.save(tempFileName)

所谓的“建立模板”方法，实际上仅执行了两项操作：创建自定义名称的Sheet页，并写入表头。因此，其本质即为写入表头。

我们可以选择返回Workbook对象（return wb），或者直接保存为文件（wb.save(tempFileName)）。

这意味着，我们可以将写好表头的Workbook对象直接返回，供后续的写入数据方法调用。

另一种做法是，直接保存为一个模板Excel文件存储在脚本后台。每次需要生成新表时，直接调用该模板文件。

此处的问题还可以进一步深入探讨。

【有了写表头的所谓建立模板方法，保存模板文件是否还有必要？】

这实际上是一个平衡问题：是每次调用方法动态写表头以消耗运行时间，还是直接调用已生成的模板文件？直接调用虽快，但模板文件会占用脚本后台的存储空间。

如何权衡？是选择时间效率还是空间占用？

此外，存在一个疑问：动态写入一定比调用文件慢吗？如果动态写入的速度快于文件I/O，则既节省时间又节省空间，仅需在代码中增加写表头的方法即可。

这种做法还便于后期的代码维护。

由此产生一个矛盾点：既然已有写表头的操作，是否还需要将其保存为模板文件？

每次运行时直接写入表头不就行了吗？为何还要额外保存？

保存文件除了占用空间外，主要用于后续调用（实际上完全可以直接写入而不必调用），其额外价值何在？

这是一个值得改进的环节。

【关于建立模板方法相关的个人暂处理办法】

目前我的处理策略是：不再额外保存模板文件。写表头即写表头，直接返回Workbook对象，并与后续写入方法串联即可。

仅在月份更替、即该月第一天生成首张表时，调用该写表头方法。

第一个问题已解决，接下来阐述第二个问题。

【从数据库取数据，进行处理以后，再写入】

以往生成Excel表时，多数情况是将取出的数据直接写入Excel表的对应位置。

数据提取方法通常一致，主要差异在于写入时的数据处理。常见的处理需求有两种：

1. 需要调用Excel相关函数，例如SUM等聚合函数。

xlwt.Formula

2. 需要对数据进行除运算外的复杂处理。本例的需求即属于此类情况。

【需求】

从数据库中提取每个游戏的成交量、下单量、失败量，生成如下结构的表格：

关键处理难点在于：每个游戏的三项数据，每项数据均通过独立的SQL查询获取，即各项数据单独提取，且排序规则不同。

若直接写入Excel表，结果如下所示：

可见，数据排序混乱。我们需要将数据按游戏名称进行一一匹配处理，生成如第一张图所示的整齐表格。

这引出了数据处理方法的选择问题。

【如何进行数据处理？】

此前想到的处理思路是：

def writeInfo0(sht, rs, length, rs2, length2, rs3, length3):
 '''写入线上具体数据'''
 for j in range(length2):
  sht.write(j+1, 0, str(rs2[j][0]).decode('utf-8'), style1)
  sht.write(j+1, 1, str(rs2[j][1]).decode('utf-8'), style1)
  sht.write(j+1, 3, rs2[j][2], style1)

 for j in range(length2):
  for i in range(length):
   if (str(rs[i][0])==str(rs2[j][0])) and (str(rs[i][1])==str(rs2[j][1])):
    sht.write(j+1, 2, rs[i][2], style1)

 for j in range(length2):
  for k in range(length3):
   if (str(rs3[k][0])==str(rs2[j][0])) and (str(rs3[k][1])==str(rs2[j][1])):
    sht.write(j+1, 4, rs3[k][2], style1)

直接进行写入。先写入数据量最多的项，再写入数据量较少的项。在写入较少项时，根据游戏名称匹配，将其放置在对应位置。此方法可行，但存在两个问题：

1. 无数据的地方需显示为零。如何判断并写入零值？这增加了逻辑复杂度。

2. 需确保数据完备性，即保证数据量最多的那项包含所有游戏吗？是否存在每项数据对应各自独有的游戏？

若数据量最多的项未包含所有游戏，将导致致命的数据缺失错误。

不仅如此，我们如何保证当前数据量最多的项，明天依然最多？若明天某项变为最少，许多数据可能因名称匹配失败而无法写入。

这依然导致数据缺失，属于严重问题。

因此，这种方法存在诸多漏洞和缺陷，不可行。

【建立字典DICT处理数据】

较为理想且最终采用的方法，是将所有提取的数据存入一个字典（Dict）中。

在存入过程中进行数据整理：若该游戏已存在，则直接赋值；若不存在，则新建Key并写入。

字典构建完成后，包含所有数据，再进行写入，这种方法更为可靠。

此方法的关键点有两个：

1. 如何在写入过程中处理数据？

2. 字典构建完成后，如何将其写入Excel？

我们逐一分析。

【如何在写入的时候，建立DICT处理数据？】

首先以较简单的线下数据写入为例进行说明。

def getInfo1(rs, rs2, rs3):
 dict={}
 for i in range(len(rs)):
  key=str(rs[i][0])
  value=rs[i][1]
  dict[key]=[value, 0, 0]

 dlist=list(dict.keys())
 for i in range(len(rs2)):
  key2=str(rs2[i][0])
  value2=rs2[i][1]
  if key2 in dlist:
   value=dict[key2][0]
  else:
   value=0
  dict[key2]=[value, value2, 0]

 dlist=list(dict.keys())
 for i in range(len(rs3)):
  key3=str(rs3[i][0])
  value3=rs3[i][1]
  if key3 in dlist:
   value=dict[key3][0]
   value2=dict[key3][1]
  else:
   value=0
   value2=0
  dict[key3]=[value, value2, value3]
 return dict

接收到的rs数据为列表（list），每个游戏对应一条数据。

处理方式为：将游戏名赋给Key，数据赋给Value。通过循环遍历，构建字典。

接下来是核心逻辑：若Key存在，直接赋值；若不存在，新建Key并写入。

该核心逻辑中更关键的部分在于：如何判断原Key是否存在。

处理方法如下：

dlist=list(dict.keys())
for i in range(len(rs2)):

if key2 in dlist: value=dict[key2][0] else: value=0 dict[key2]=[value, value2, 0] 若Key存在，则从当前状态的字典中获取第一个Value的值。

若Key不存在，则Value直接取0。

最后，直接

dict[key2]=[value, value2, 0]

即，Key均为动态建立。我们只需关注Value的值即可。

【疑问】

这里有一个疑问：是否会出现重复建立Key的情况？

不会。因为

dict[key2]=[value, value2, 0]

该赋值语句中的等号（=）符号，兼具赋值和新建的双重用途。若Key不存在，则新建；若Key已存在，则修改。

仅在修改时，我们需要将原值一并带入。该原值从已存在的字典中获取即可。

接下来，更复杂的代码逻辑也可据此理解。

dlist=list(dict.keys())
for i in range(len(rs3)):
 key3=str(rs3[i][0])
 value3=rs3[i][1]
 if key3 in dlist:
  value=dict[key3][0]
  value2=dict[key3][1]
 else:
  value=0
  value2=0
 dict[key3]=[value, value2, value3]
return dict

第三项数据出现时，建立字典的情况如上所示。

只需顾及两项已写入的数据即可。

【如何将DICT写入Excel表】

def writeInfo1(sht, dict):
 '''写入线下具体数据'''
 dlist=list(dict.keys())
 for i in range(len(dlist)):
  sht.write(i+1, 0, str(dlist[i]).decode('utf-8'), style1)
  sht.write(i+1, 1, dict[dlist[i]][0], style1)
  sht.write(i+1, 2, dict[dlist[i]][1], style1)
  sht.write(i+1, 3, dict[dlist[i]][2], style1)

这实质上是字典层层解包的过程。

关键在于获取数据，获取后直接写入即可！

对于稍复杂的字典，处理线上数据时，我们的键有两个，值有三个。

我们知道，字典的数据类型中，Value可以是包含多个数据的数组，但Key只能有一个，且不能为数组。

如何处理？我们只能将多个Key合并为一个Key，然后在写入时再拆分。

关键问题在于合并与拆分。

【键的合并】

key=str(rs[i][0])+'--'+str(rs[i][1])

是的，仅此而已。将两个数据连接在一起，合并为一个字符串。

【写入时键的拆分】

sht.write(i+1, 0, str(dlist[i]).decode('utf-8').split('--')[0], style1)
sht.write(i+1, 1, str(dlist[i]).decode('utf-8').split('--')[1], style1)

使用split函数。

split函数对字符串进行拆分，结果为数组。按数组编号取出分开的数据即可。

至此，该需求的关键问题均已说明完毕。

最后贴出一份完整代码供参考。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

__author__ = "$Author: wangxin.xie$"
__version__ = "$Revision: 1.0 $"
__date__ = "$Date: 2018$"

###############################################################
#功能： 订单情况相关报表
###############################################################
import sys
import datetime
import xlwt
from myyutil.DBUtil import DBUtil
reload(sys)
sys.setdefaultencoding('utf8')
#######################全局变量####################################

orderDBUtil = DBUtil('moyoyo_order')

fileDir = 'D://'
fileName = fileDir+'order_message_test2.xls'

style1 = xlwt.XFStyle()
font1 = xlwt.Font()
font1.height = 220
font1.name = 'SimSun'
style1.font = font1

##################################################################
def createTemplateExcel():
 '''创建Excel文件模板'''
 wb = xlwt.Workbook(encoding = "UTF-8", style_compression = True)
 sht0 = wb.add_sheet("线上", cell_overwrite_ok = True)
 sht0.col(0).width=4000
 sht0.write(0, 0, '游戏名称', style1)
 sht0.write(0, 1, '渠道', style1)
 sht0.write(0, 2, '成交量', style1)
 sht0.write(0, 3, '下单量', style1)
 sht0.write(0, 4, '失败量', style1)

 sht1 = wb.add_sheet("线下", cell_overwrite_ok = True)
 sht1.col(0).width=4000
 sht1.write(0, 0, '游戏名称', style1)
 sht1.write(0, 1, '成交量', style1)
 sht1.write(0, 2, '下单量', style1)
 sht1.write(0, 3, '失败量', style1)
 return wb

def genSuccessOrderOnline():
 sql = '''
  SELECT A.GAME_NAME,
  A.GOODS_NAME,
  COUNT(B.ORDER_ID)
  FROM moyoyo_order.BASE_INFO B
  INNER JOIN moyoyo_order.ACCOUNT_INFO A ON B.ORDER_ID = A.ORDER_ID
  INNER JOIN netgame_trade.GOODS G ON A.GOODS_ID = G.ID
  LEFT JOIN moyoyo_order.RELATION_INFO R ON B.ORDER_ID = R.PARENT_ORDER_ID
  WHERE B.COMPLETE_DATE >= DATE_SUB(NOW(), INTERVAL 7 DAY)
  AND B.COMPLETE_DATE < NOW()
  AND A.CS_ADMIN_ID != 241
  AND A.GOODS_ID != 1213
  AND G.GOODS_TYPE_ID != 6
  AND A.GOODS_IS_OFFLINE = 0
  AND A.IS_B2C IS NULL
  AND (
   (
    A.GOODS_ID IN (1240, 1241, 1608)
    AND B.SELLER_ID IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   ) OR (
    B.SELLER_ID NOT IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   )
  )
  AND R.PARENT_ORDER_ID IS NULL
  AND B.SELLER_ID NOT IN (693356, 14791127)
  AND B.STATUS = 1
  AND B.TRADE_STATUS = 4
  AND B.TYPE = 1
  GROUP BY A.GAME_ID, G.GOODS_CHANNEL_ID
  ORDER BY COUNT(B.ORDER_ID) DESC;
 '''
 rs = orderDBUtil.queryList(sql, ())
 if not rs: return None
 return rs

def genGenerateOrderOnline():
 sql = '''
  SELECT A.GAME_NAME,
  A.GOODS_NAME,
  COUNT(B.ORDER_ID)
  FROM moyoyo_order.BASE_INFO B
  INNER JOIN moyoyo_order.ACCOUNT_INFO A ON B.ORDER_ID = A.ORDER_ID
  INNER JOIN netgame_trade.GOODS G ON A.GOODS_ID = G.ID
  LEFT JOIN moyoyo_order.RELATION_INFO R ON B.ORDER_ID = R.PARENT_ORDER_ID
  WHERE B.CREATED_DATE >= DATE_SUB(NOW(), INTERVAL 7 DAY)
  AND B.CREATED_DATE < NOW()
  AND A.CS_ADMIN_ID != 241
  AND A.GOODS_ID != 1213
  AND G.GOODS_TYPE_ID != 6
  AND A.GOODS_IS_OFFLINE = 0
  AND A.IS_B2C IS NULL
  AND (
   (
    A.GOODS_ID IN (1240, 1241, 1608)
    AND B.SELLER_ID IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   ) OR (
    B.SELLER_ID NOT IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   )
  )
  AND R.PARENT_ORDER_ID IS NULL
  AND B.SELLER_ID NOT IN (693356, 14791127)
  AND B.STATUS = 1
  AND B.TYPE = 1
  GROUP BY A.GAME_ID, G.GOODS_CHANNEL_ID
  ORDER BY COUNT(B.ORDER_ID) DESC;
 '''
 rs = orderDBUtil.queryList(sql, ())
 if not rs: return None
 return rs

def genFailOrderOnline():
 sql = '''
  SELECT A.GAME_NAME,
  A.GOODS_NAME,
  COUNT(B.ORDER_ID)
  FROM moyoyo_order.BASE_INFO B
  INNER JOIN moyoyo_order.ACCOUNT_INFO A ON B.ORDER_ID = A.ORDER_ID
  INNER JOIN netgame_trade.GOODS G ON A.GOODS_ID = G.ID
  LEFT JOIN moyoyo_order.RELATION_INFO R ON B.ORDER_ID = R.PARENT_ORDER_ID
  WHERE B.COMPLETE_DATE >= DATE_SUB(NOW(), INTERVAL 7 DAY)
  AND B.COMPLETE_DATE < NOW()
  AND A.CS_ADMIN_ID != 241
  AND A.GOODS_ID != 1213
  AND G.GOODS_TYPE_ID != 6
  AND A.GOODS_IS_OFFLINE = 0
  AND A.IS_B2C IS NULL
  AND (
   (
    A.GOODS_ID IN (1240, 1241, 1608)
    AND B.SELLER_ID IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   ) OR (
    B.SELLER_ID NOT IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   )
  )
  AND R.PARENT_ORDER_ID IS NULL
  AND B.SELLER_ID NOT IN (693356, 14791127)
  AND B.STATUS = 1
  AND B.TRADE_STATUS = 5
  AND B.TYPE = 1
  GROUP BY A.GAME_ID, G.GOODS_CHANNEL_ID
  ORDER BY COUNT(B.ORDER_ID) DESC;
 '''
 rs = orderDBUtil.queryList(sql, ())
 if not rs: return None
 return rs

def genSuccessOrderOffline():
 sql = '''
  SELECT A.GAME_NAME,
  COUNT(B.ORDER_ID)
  FROM moyoyo_order.BASE_INFO B
  INNER JOIN moyoyo_order.ACCOUNT_INFO A ON B.ORDER_ID = A.ORDER_ID
  INNER JOIN netgame_trade.GOODS G ON A.GOODS_ID = G.ID
  LEFT JOIN moyoyo_order.RELATION_INFO R ON B.ORDER_ID = R.PARENT_ORDER_ID
  WHERE B.COMPLETE_DATE >= DATE_SUB(NOW(), INTERVAL 7 DAY)
  AND B.COMPLETE_DATE < NOW()
  AND A.CS_ADMIN_ID != 241
  AND A.GOODS_ID != 1213
  AND G.GOODS_TYPE_ID != 6
  AND A.GOODS_IS_OFFLINE = 1
  AND A.IS_B2C IS NULL
  AND (
   (
    A.GOODS_ID IN (1240, 1241, 1608)
    AND B.SELLER_ID IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   ) OR (
    B.SELLER_ID NOT IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   )
  )
  AND R.PARENT_ORDER_ID IS NULL
  AND B.SELLER_ID NOT IN (693356, 14791127)
  AND B.STATUS = 1
  AND B.TRADE_STATUS = 4
  AND B.TYPE = 1
  GROUP BY A.GAME_ID
  ORDER BY COUNT(B.ORDER_ID) DESC;
  '''
 rs = orderDBUtil.queryList(sql, ())
 if not rs: return None
 return rs

def genGenerateOrderOffline():
 sql = '''
  SELECT A.GAME_NAME,
  COUNT(B.ORDER_ID)
  FROM moyoyo_order.BASE_INFO B
  INNER JOIN moyoyo_order.ACCOUNT_INFO A ON B.ORDER_ID = A.ORDER_ID
  INNER JOIN netgame_trade.GOODS G ON A.GOODS_ID = G.ID
  LEFT JOIN moyoyo_order.RELATION_INFO R ON B.ORDER_ID = R.PARENT_ORDER_ID
  WHERE B.CREATED_DATE >= DATE_SUB(NOW(), INTERVAL 7 DAY)
  AND B.CREATED_DATE < NOW()
  AND A.CS_ADMIN_ID != 241
  AND A.GOODS_ID != 1213
  AND G.GOODS_TYPE_ID != 6
  AND A.GOODS_IS_OFFLINE = 1
  AND A.IS_B2C IS NULL
  AND (
   (
    A.GOODS_ID IN (1240, 1241, 1608)
    AND B.SELLER_ID IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   ) OR (
    B.SELLER_ID NOT IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   )
  )
  AND R.PARENT_ORDER_ID IS NULL
  AND B.SELLER_ID NOT IN (693356, 14791127)
  AND B.STATUS = 1
  AND B.TYPE = 1
  GROUP BY A.GAME_ID
  ORDER BY COUNT(B.ORDER_ID) DESC;
 '''
 rs = orderDBUtil.queryList(sql, ())
 if not rs: return None
 return rs

def genFailOrderOffline():
 sql = '''
  SELECT A.GAME_NAME,
  COUNT(B.ORDER_ID)
  FROM moyoyo_order.BASE_INFO B
  INNER JOIN moyoyo_order.ACCOUNT_INFO A ON B.ORDER_ID = A.ORDER_ID
  INNER JOIN netgame_trade.GOODS G ON A.GOODS_ID = G.ID
  LEFT JOIN moyoyo_order.RELATION_INFO R ON B.ORDER_ID = R.PARENT_ORDER_ID
  WHERE B.COMPLETE_DATE >= DATE_SUB(NOW(), INTERVAL 7 DAY)
  AND B.COMPLETE_DATE < NOW()
  AND A.CS_ADMIN_ID != 241
  AND A.GOODS_ID != 1213
  AND G.GOODS_TYPE_ID != 6
  AND A.GOODS_IS_OFFLINE = 1
  AND A.IS_B2C IS NULL
  AND (
   (
    A.GOODS_ID IN (1240, 1241, 1608)
    AND B.SELLER_ID IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   ) OR (
    B.SELLER_ID NOT IN (
     SELECT MEMBER_ID
     FROM netgame_trade.B2C_MEMBER
    )
   )
  )
  AND R.PARENT_ORDER_ID IS NULL
  AND B.SELLER_ID NOT IN (693356, 14791127)
  AND B.STATUS = 1
  AND B.TRADE_STATUS = 5
  AND B.TYPE = 1
  GROUP BY A.GAME_ID
  ORDER BY COUNT(B.ORDER_ID) DESC;
 '''
 rs = orderDBUtil.queryList(sql, ())
 if not rs: return None
 return rs

def getInfo0(rs, rs2, rs3):
 dict={}
 for i in range(len(rs)):
  key=str(rs[i][0])+'--'+str(rs[i][1])
  value=rs[i][2]
  dict[key]=[value, 0, 0]

 dlist=list(dict.keys())
 for i in range(len(rs2)):
  key2=str(rs2[i][0])+'--'+str(rs2[i][1])
  value2=rs2[i][2]
  if key2 in dlist:
   value=dict[key2][0]
  else:
   value=0
  dict[key2]=[value, value2, 0]

 dlist=list(dict.keys())
 for i in range(len(rs3)):
  key3=str(rs3[i][0])+'--'+str(rs3[i][1])
  value3=rs3[i][2]
  if key3 in dlist:
   value=dict[key3][0]
   value2=dict[key3][1]
  else:
   value=0
   value2=0
  dict[key3]=[value, value2, value3]
 return dict

def writeInfo0(sht, dict):
 '''写入线上具体数据'''
 dlist=list(dict.keys())
 for i in range(len(dlist)):
  sht.write(i+1, 0, str(dlist[i]).decode('utf-8').split('--')[0], style1)
  sht.write(i+1, 1, str(dlist[i]).decode('utf-8').split('--')[1], style1)
  sht.write(i+1, 2, dict[dlist[i]][0], style1)
  sht.write(i+1, 3, dict[dlist[i]][1], style1)
  sht.write(i+1, 4, dict[dlist[i]][2], style1)

def getInfo1(rs, rs2, rs3):
 '''拿到线下具体数据'''
 dict={}
 for i in range(len(rs)):
  key=str(rs[i][0])
  value=rs[i][1]
  dict[key]=[value, 0, 0]

 dlist=list(dict.keys())
 for i in range(len(rs2)):
  key2=str(rs2[i][0])
  value2=rs2[i][1]
  if key2 in dlist:
   value=dict[key2][0]
  else:
   value=0
  dict[key2]=[value, value2, 0]

 dlist=list(dict.keys())
 for i in range(len(rs3)):
  key3=str(rs3[i][0])
  value3=rs3[i][1]
  if key3 in dlist:
   value=dict[key3][0]
   value2=dict[key3][1]
  else:
   value=0
   value2=0
  dict[key3]=[value, value2, value3]
 return dict

def writeInfo1(sht, dict):
 '''写入线下具体数据'''
 dlist=list(dict.keys())
 for i in range(len(dlist)):
  sht.write(i+1, 0, str(dlist[i]).decode('utf-8'), style1)
  sht.write(i+1, 1, dict[dlist[i]][0], style1)
  sht.write(i+1, 2, dict[dlist[i]][1], style1)
  sht.write(i+1, 3, dict[dlist[i]][2], style1)


def writeExcel():
 '''写报表'''
 wb = createTemplateExcel()

 rs=genSuccessOrderOnline()
 rs2=genGenerateOrderOnline()
 rs3=genFailOrderOnline()

 sheet0 = wb.get_sheet(0)
 dict0=getInfo0(rs, rs2, rs3)
 writeInfo0(sheet0, dict0)

 rs4=genSuccessOrderOffline()
 rs5=genGenerateOrderOffline()
 rs6=genFailOrderOffline()

 sheet1 = wb.get_sheet(1)
 dict1=getInfo1(rs4, rs5, rs6)
 writeInfo1(sheet1, dict1)

 wb.save(fileName)

def main():
 print "===%s start===%s"%(sys.argv[0], datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S"))
 writeExcel()
 print "===%s end===%s"%(sys.argv[0], datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S"))

if __name__ == '__main__':
 try:
  main()
 finally:
  if orderDBUtil: orderDBUtil.close()