目前有比较成熟的Python读写Excel包，比如xlrd、xlwt、xlsxwriter、openpyxl等等，但是需要对既有Excel内容进行修改是一个相对麻烦的操作，可以参考以下代码进行实现。
 
import xlrd
from xlutils.copy import copy

file = 'test.xls'
read_book = xlrd.open_workbook(file)
write_book = copy(read_book)
sheet = write_book.get_sheet(0)
sheet.write(1, 2, 3)
write_book.save('test.xls')

import xlrd
from xlutils.copy import copy

#打开Excel
wb=xlrd.open_workbook('excel的url')
#打开Excel的sheet(获取方法有很多自己选!我这里用的index)
sheet1=wb.sheet_by_index(0)
#复制打开的Excel
newBook=copy(wb)
#打开复制过的Excel的sheet
newSheet=newBook.get_sheet(0)#这里的get方法系统没有提示,我也不知道为什么.求解!
#讲数据写入到刚刚复制的Excel里
newSheet.write(1,1,'我真帅')#参数1:表示第几行;参数2:表示第几列;参数3:写你修改后的内容
#最后保存到指定路径
newBook.save('Excel的url')
 
 

 创建导出Excel工具类
 
package com.jlpt.utils;

import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.RegionUtil;

import java.util.Arrays;


public class ExcelUtil {

    /**
     * @param sheetName
     * @param ProhibitToEdit 是否禁止编辑，true则生成的表无法编辑，内容高亮显示，若允许某列可以编辑，可配置enableChange
     * @param enableChange   禁止修编辑，允许编辑的列；配置后显示可编辑并取消高亮
     * @param title          标题
     * @param calWidth       行宽,若传值为null或长度小于标题长度，则自动填充行宽15字符长度
     * @param values         内容
     * @return
     */
    public static HSSFWorkbook getHSSFWorkbook(String sheetName, boolean ProhibitToEdit, int[] enableChange, String[] title,int[] calWidth, String[][] values) {

        // 创建一个HSSFWorkbook，对应一个Excel文件
        HSSFWorkbook wb = new HSSFWorkbook();

        // 在workbook中添加一个sheet,对应Excel文件中的sheet
        HSSFSheet sheet = wb.createSheet(sheetName);

        // 在sheet中添加表头第0行,注意老版本poi对Excel的行数列数有限制
        HSSFRow row = null;

        // 创建单元格，并设置值表头 设置表头居中

        //单元格样式
        HSSFCellStyle style = wb.createCellStyle();
        style.setAlignment(HSSFCellStyle.ALIGN_CENTER); // 创建一个居中格式
        style.setBorderBottom(CellStyle.BORDER_THIN); // 下边框
        style.setBorderLeft(CellStyle.BORDER_THIN);// 左边框
        style.setBorderTop(CellStyle.BORDER_THIN);// 上边框
        style.setBorderRight(CellStyle.BORDER_THIN);// 右边框
        style.setWrapText(true);//自动换行

        HSSFCellStyle lockStyle = wb.createCellStyle();//列未锁定样式
        lockStyle.setLocked(false);   //设置列的锁定状态为未锁定
        lockStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER); // 创建一个居中格式
        lockStyle.setBorderBottom(CellStyle.BORDER_THIN); // 下边框
        lockStyle.setBorderLeft(CellStyle.BORDER_THIN);// 左边框
        lockStyle.setBorderTop(CellStyle.BORDER_THIN);// 上边框
        lockStyle.setBorderRight(CellStyle.BORDER_THIN);// 右边框
        lockStyle.setWrapText(true);//自动换行
        //字体样式
        Font fontStyle = wb.createFont(); // 字体样式
        fontStyle.setBoldweight((short) 4); // 加粗
        fontStyle.setFontName("黑体"); // 字体
        fontStyle.setFontHeightInPoints((short) 11); // 大小
        //合并单元格CellRangeAddress构造参数依次表示起始行，截至行，起始列， 截至列
        CellRangeAddress cra = new CellRangeAddress(0, 0, 0, 14);
        sheet.addMergedRegion(cra);
        RegionUtil.setBorderBottom(1, cra, sheet, wb); // 下边框
        RegionUtil.setBorderLeft(1, cra, sheet, wb); // 左边框
        RegionUtil.setBorderRight(1, cra, sheet, wb); // 有边框
        RegionUtil.setBorderTop(1, cra, sheet, wb); // 上边框

        //声明列对象
        HSSFCell cell = null;
        HSSFCell headercell = null;
        //标头样式
        HSSFRow row1 = sheet.createRow(0);
        HSSFCellStyle headerStyle = style;
        //Height的单位是1/20个点
        row1.setHeight((short) 600);
        headercell = row1.createCell(0);
        headercell.setCellValue("用户信息列表");
        headercell.setCellStyle(headerStyle);

        int [] reallyWidth=new int[title.length];
        Arrays.fill(reallyWidth,15);//设置默认列宽15字符长度（英）
        //设置列宽
        if(calWidth!=null){
            if(calWidth.length<title.length){
                reallyWidth=Arrays.copyOf(calWidth,calWidth.length);
            }else{
                reallyWidth=calWidth;
            }
        }

        //标题
        row = sheet.createRow(1);
        //创建标题
        for (int i = 0; i < title.length; i++) {
            //设置列宽度(参数的单位是1/256个字符宽度)
            sheet.setColumnWidth(i, reallyWidth[i] * 256);
            HSSFCellStyle titleStyle = style;
            titleStyle.setFont(fontStyle);
            cell = row.createCell(i);
            cell.setCellValue(title[i]);
            cell.setCellStyle(titleStyle);
        }

        //创建内容
        if (ProhibitToEdit) {//禁止修改
            sheet.protectSheet("123456");
            style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);  //填充单元格
            style.setFillForegroundColor(HSSFColor.LIME.index);    //填蓝色
            HSSFPalette palette = wb.getCustomPalette();
            palette.setColorAtIndex(HSSFColor.LIME.index, (byte) 221, (byte) 235, (byte) 247);
            if (enableChange != null) {//禁止修改后，允许编辑的列

                for (int i = 0; i < values.length; i++) {
                    row = sheet.createRow(i + 2);
                    for (int j = 0; j < values[i].length; j++) {
                        //将内容按顺序赋给对应的列对象
                        row.createCell(j).setCellValue(values[i][j]);
                        row.getCell(j).setCellStyle(style);
                    }
                    for (int columns : enableChange) {
                        row.getCell(columns).setCellStyle(lockStyle);
                    }
                }
            } else {
                for (int i = 0; i < values.length; i++) {
                    row = sheet.createRow(i + 2);
                    for (int j = 0; j < values[i].length; j++) {
                        //将内容按顺序赋给对应的列对象
                        row.createCell(j).setCellValue(values[i][j]);
                        row.getCell(j).setCellStyle(style);
                    }
                }
            }
        } else {
            for (int i = 0; i < values.length; i++) {
                row = sheet.createRow(i + 1);
                for (int j = 0; j < values[i].length; j++) {
                    //将内容按顺序赋给对应的列对象
                    row.createCell(j).setCellValue(values[i][j]);
                }
            }
        }
        return wb;
    }
}
 
controller控制器代码
 
    //批量导出
    @RequestMapping("/userExport")

    public String userExport(String orgId, HttpServletResponse response, HttpServletRequest request) {
        //获取数据
        List<UserInfo> userList= userService.getUserListByOrgId(orgId);
        int userNumber = userList.size();

        //excel标题
        String[] title = {"用户名", "真实姓名", "密码", "性别", "手机号","电话","邮箱","单位编码","用户编码","工作证号","职务","科室/处室","绑定IP","所在部门"};

        //excel文件名
        String fileName = "用户信息表" + System.currentTimeMillis() + ".xls";

        //sheet名
        String sheetName = "用户信息表";

        String [][] content=new String[userNumber][];
        for (int i = 0; i < userList.size(); i++) {
            content[i] = new String[title.length];
            UserInfo userInfo = userList.get(i);

            content[i][0] = userInfo.getUserName();
            content[i][1] = userInfo.getRealName();
            content[i][2] = userInfo.getPassword();
            content[i][3] = userInfo.getSex()=="0"?"男":"女";
            content[i][4] = userInfo.getCellPhone();
            content[i][5] = userInfo.getPhone();
            content[i][6] = userInfo.getEmail();
            content[i][7] = userInfo.getOrgCode();
            content[i][8] = userInfo.getUserCode();
            content[i][9] = userInfo.getCardId();
            content[i][10] = userInfo.getDuty();
            content[i][11] = userInfo.getDepartment();
            content[i][12] = userInfo.getIp();
        }
        //设置列宽
        int[] calWidth=new int[]{8,16,12,12,6,14,14,30,12,12,20,12,12,30,10};
        //创建HSSFWorkbook
        HSSFWorkbook wb = ExcelUtil.getHSSFWorkbook(sheetName,false,null, title,calWidth, content );

        //响应到客户端
        try {
            this.setResponseHeader(response, fileName);
            OutputStream ops = response.getOutputStream();
            wb.write(ops);
            ops.flush();
            ops.close();
        } catch (Exception e) {
            e.printStackTrace();

        }

        return null;
    }
//发送响应流方法
    public void setResponseHeader(HttpServletResponse response, String fileName) {
        try {
            try {
                fileName = new String(fileName.getBytes(),"ISO8859-1");
            } catch (UnsupportedEncodingException e) {

                e.printStackTrace();
            }
            response.setContentType("application/octet-stream;charset=ISO8859-1");
            response.setHeader("Content-Disposition", "attachment;filename="+ fileName);
            response.addHeader("Pargam", "no-cache");
            response.addHeader("Cache-Control", "no-cache");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
 

一、问题的来源以及网上的错误方法
 
最近遇到了一个问题，给定了一个Excel模板，修改表格里面的内容，但是不能修改Excel表格的格式。用pywin32太慢，用xlrd只能读，用xlwt只能写。
 
很快，我查到了网上“修改Excel内容但保留格式”的方法，大概是需要用到另一个辅助的库xlutils，并为formatting_info参数配置为True，代码大概是这样的：
 
import xlrd
import xlwt
from xlutils.copy import copy

rb = xlrd.open_workbook('open.xls', formatting_info=True)
wb = copy(rb)

sheet = wb.get_sheet(0)
for r in range(8):
    for c in range(5):
        sheet.write(r, c, 'R%sC%s'%(r+1, c+1))

wb.save('save.xls')
 
大部分格式的确是保住了，但是“修改了”的部分的格式惨不忍睹，一看这就是默认格式嘛。
 
于是继续查找，发现xlwt.Worksheet（工作表）对象的write函数的用法参数说明为：
 
write(r, c, label='', style=<xlwt.Style.XFStyle object at 0x0186A530>)
 
网上找到的教程也有说明，只要配置xlwt库的XFStyle类，并为write函数的第4个参数赋值，就可以为新写入的单元格设置单元格格式了。代码类似于这样，这段代码实现了对RC位置的单元格设置了20号宋体、上下水平居中、四边边框：
 
style = xlwt.XFStyle()
style.font.height = 400
style.font.name = '宋体'
style.alignment.horz = xlwt.Alignment.HORZ_CENTER
style.alignment.vert = xlwt.Alignment.VERT_CENTER
style.borders.left    = xlwt.Borders.THIN
style.borders.right   = xlwt.Borders.THIN
style.borders.top     = xlwt.Borders.THIN
style.borders.bottom  = xlwt.Borders.THIN

sheet.write(r, c, 'R%sC%s'%(r+1, c+1), style)
 
然而众所周知，xlwt库只能写不能读，相当于我在设置单元格的样式的，原表格的样式对我是“盲”的。虽然我可以“手动”地记下来所有单元格的格式，然后“抄”过去，但是这多蛋疼啊。
 
于是继续网上查找资料，全部都是答非所问的结果，要么告诉我“怎么复制原表格而保留样式”，要么告诉我“如何修改单元格同时配置格式”，但没有一个是回答“如何修改单元格而保留格式”的。
 
 
 
二、根据属性名猜可以用的函数
 
没办法，代码小白的我，只好继续猜，猜猜看那个函数能做到这样的配置。
 
首先我尝试为工作表对象sheet的sheet.write函数的第4个参数配置“默认”项，企图让它“write”单元格的时候“不修改”格式，比如False啊、0啊、None啊、-1啊，都试过了，全部报错。
 
那么尝试找xlrd读取的单元格的cell对象，看看里面有没有存储格式信息。但是cell对象中的属性不多，很快就爬干净了，没有存储格式这样如此“细致”的内容。
 
线索断了，我只好穷举用xlrd读取的工作簿rb的所有属性函数，突然发现了一个看起来很像记录格式的东西，rb.xf_list，其中是一个大列表，里面记录的全是“xlrd.formatting.XF”类型的对象，而字体格式的对象名字不是叫做“XFStyle”吗，这可是非常一致了。
 
这可是一个很大的突破，我猜想Excel中的单元格格式，不是分别记录到各个单元格的对象的属性中，而是将工作簿中出现的样式汇总，再通过另一个方法把各个单元格设定的格式的“索引编号”读出来，于是就做到了记录各个单元格的格式信息。
 
得到了线索就有了进展，我找到xlrd读取的工作表sheet对象有一个sheet.cell_xf_index(rowx, colx)函数，返回结果是一个数值，而且针对相同格式的单元格布局，这个结果在相同格式单元格中计算返回的索引编号很一致！那么结果肯定是这个了！
 
于是我急急忙忙把rb.xf_list[sheet.cell_xf_index(rowx, colx)]赋值到了sheet.write函数的style参数上，期待奇迹的发生。
 
 
 
三、瞎猫碰不到死耗子，那就硬着头皮爬源码
 
果不其然，事情的进展不会这么顺利，果然出现了报错。
 
我突然想起来了write函数的说明，style的默认参数设置是“style=<xlwt.Style.XFStyle object at 0x0186A530>”，而我赋值的是“xlrd.formatting.XF”对象，这都不是一个库的东西，怎么能直接用呢。
 
但是我坚定一个信念，既然通过xlutils.copy库的copy函数可以把格式“复制”过去，那么肯定在某个时候发生了读取和写入，这个格式读写的“管道”肯定是通的，关键是我要找到它。
 
于是我撑住头皮，开始爬xlutils库的代码，xlutils.copy库的内容很干净，代码只有这些：
 
from xlutils.filter import process,XLRDReader,XLWTWriter

def copy(wb):
    w = XLWTWriter()
    process(
        XLRDReader(wb,'unknown.xls'),
        w
        )
    return w.output[0][1]
 
于是转头去爬这里引用了的xlutils.filter库。既然知道了rb.xf_list存储了xlrd格式的“单元格样式”，那么就找找看它什么时候转化为了xlwt格式的“单元格样式”。
 
按照关键词搜索，果然找了一系列的判断和转换，代码段大概是这样的：
 
for rdxf in rdbook.xf_list:
    wtxf = xlwt.Style.XFStyle()

    ... 各种判断和转换

    self.style_list.append(wtxf)
 
那么很显然，我要找的就是self.style_list了。
 
那么按理说，我只要获取到“self.style_list”的“self”，也就是它的父对象“BaseWriter”的实例，就能获取到这个属性了（也只有这个方法）。但是我惊讶地发现BaseWriter里面有一个close方法，里面赫然写着“del self.style_list”，这可了得，我虽然不知道它是在什么时候调用了，但是一旦调用了，那不就功亏一篑了，这个列表删掉了那不就全完了。
 
再看看xlutils.copy库里的内容，找到对应的定义：
 
class XLWTWriter(BaseWriter):
    def __init__(self):
        self.output = []

    def close(self):
        if self.wtbook is not None:
            self.output.append((self.wtname,self.wtbook))
            del self.wtbook
 
最终copy函数中的定义中返回的是“w.output[0][1]”，那实际上就是“self.wtbook”这个东西了。
 
接着找相关定义，可以看到这样一段：
 
...
self.wtbook = xlwt.Workbook(style_compression=2)
self.wtbook.dates_1904 = rdbook.datemode
self.wtname = wtbook_name
self.style_list = []
...
 
这可麻烦了呀，wtbook和style_list是BaseWriter类下的两个平级的属性，并没有相互的联系，并且wtbook是一个xlwt.Workbook类型的对象，自然不可能提供获取其父对象的方法（确认了属性也确实没有），这可咋办，进度又陷入了停滞。
 
于是我又灵机一动，“copy”函数虽然是已经封装好的，但是我也可以把它拆开，就比方说这样：
 
from xlutils.filter import process, XLRDReader, XLWTWriter

rb = xlrd.open_workbook('open.xls', formatting_info=True)
w = XLWTWriter()
process(XLRDReader(rb, 'unknown.xls'), w)
wb = w.output[0][1]
 
w是一个XLWTWriter类的对象，而XLWTWriter继承于BaseWriter，BaseWriter有style_list属性。那么我尝试访问其style_list属性，也就是“w.style_list”，并按照之前猜想的方法，将sheet.cell_xf_index函数获取到的每个单元格的对应数字，认为是“w.style_list”列表中的查询单元格样式的序列号，写入程序：
 
style_list = w.style_list
sheet2 = wb.get_sheet(0)
style = style_list[sheet.cell_xf_index(r, c)]
sheet2.write(r, c, sheet.cell_xf_index(r, c), style)
 
再次打开生成的保存文件，发现格式完美地保留了下来，而内容却如我设定地修改了，至此，程序调试任务完成！
 
 
 
四、终于可以运行的完整代码
 
完整样例代码是：
 
可以用xlrd获取打开的Excel的每个单元格的格式，并转化为xlwt写入单元格时支持的XFStyle样式参数。
 
代码可以实现用xlrd打开Excel后，用xlwt写入单元格内容，而不修改单元格的格式（如果要修改部分原始单元格的格式也可以，只要修改获取到的style的部分属性就可以）
 
import xlrd
from xlutils.filter import process, XLRDReader, XLWTWriter

rb = xlrd.open_workbook('open.xls', formatting_info=True)

# 参考xlutils.copy库内的用法 参考xlutils.filter内的参数定义style_list
w = XLWTWriter()
process(XLRDReader(rb, 'unknown.xls'), w)
wb = w.output[0][1]
style_list = w.style_list

for n, sheet in enumerate(rb.sheets()):
    sheet2 = wb.get_sheet(n)
    for r in range(sheet.nrows):
        for c, cell in enumerate(sheet.row_values(r)):
            style = style_list[sheet.cell_xf_index(r, c)]
            sheet2.write(r, c, sheet.cell_xf_index(r, c), style)

wb.save('save.xls')