• Python

    1. 安装 
      pip install xlrd        # 读xls
      pip install xlwt　     # 写xls
      pip install xlutils     # 改写xls

    2. 读取 Excel 文件
      from mmap import mmap,ACCESS_READ
      # mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。     
      # ACCESS_READ 读文件
      from xlrd import open_workbook
      # 通过open_workbook返回的xlrd.Book对象包含了所有对工作簿要的事情，能被用于在工作簿中取得独立的sheet。 

      #方法一
      print (open_workbook('simple.xls')) 

      #方法二
      with open(      'simple.xls','rb') as f:    
    print (open_workbook(
        file_contents=mmap(f.fileno(),0,access=ACCESS_READ)        
        ))

      #方法三 
aString       = open('simple.xls','rb').read() 
print (open_workbook(file_contents=aString))

      读取

      结合一段简单的代码来看：

      import xlrd

      # 打开 xls 文件

      book = xlrd.open_workbook("test.xls")

      print "表单数量:", book.nsheets

      print "表单名称:", book.sheet_names()

      # 获取第1个表单

      sh = book.sheet_by_index(0)

      print u"表单 %s 共 %d 行 %d 列" % (sh.name, sh.nrows, sh.ncols)

      print "第二行第三列:", sh.cell_value(1, 2)

      # 遍历所有表单

      for s in book.sheets():

          for r in range(s.nrows):

              # 输出指定行

              print s.row(r)

      测试文件：

      输出结果：

      表单数量: 2

      表单名称: [u'Group.A', u'Group.B']

      表单 Group.A 共 7 行 3 列

      第二行第三列: 15.0

      [text:u'Rank', text:u'Team', text:u'Points']

      [number:1.0, text:u'Brazil', number:15.0]

      [number:2.0, text:u'Russia', number:12.0]

      ...

      常用的方法：

      • open_workbook 打开文件

      • sheet_by_index 获取某一个表单

      • sheets 获取所有表单

      • cell_value 获取指定单元格的数据

      写入

      还是看代码：

      import xlwt

      # 创建 xls 文件对象

      wb = xlwt.Workbook()

      # 新增一个表单

      sh = wb.add_sheet('A Test Sheet')

      # 按位置添加数据

      sh.write(0, 0, 1234.56)

      sh.write(1, 0, 8888)

      sh.write(2, 0, 'hello')

      sh.write(2, 1, 'world')

      # 保存文件

      wb.save('example.xls')

      生成文件：

      常用的方法：

      • Workbook 创建文件对象

      • add_sheet 新增一个表单

      • write 在指定单元格写入数据

      修改

      很遗憾，并没有直接修改 xls 文件的方法。通常的做法是，读取出文件，复制一份数据，对其进行修改，再保存。

      在复制时，需要用到 xlutils 中的方法。

      from xlrd import open_workbook

      from xlutils.copy import copy

      # 打开文件

      rb = open_workbook("example.xls")

      # 复制

      wb = copy(rb)

      # 选取表单

      s = wb.get_sheet(0)

      # 写入数据

      s.write(0, 1, 'new data')

      # 保存

      wb.save('example.xls')

      修改后文件：

      特别要注意的是，选取读取表单时，要使用 sheet_by_index，而在选取写入表单时，则要用 get_sheet。不要问我为什么，我也很想知道这么设定的用意何在……

      时间转换

      如果表单中有时间格式的数据，通过处理之后，你会发现时间数据出了差错。

      输出单元格内容：

      [number:8888.0, xldate:42613.0]

      因为这里 xldate 有自己的格式定义。如果要使用正确的格式，必须转换：

      new_date = xlrd.xldate.xldate_as_datetime(date, book.datemode)

      date 是对应单元格的数据，book 是打开的文件对象。

      另外，在打开文件时，加上参数 formatting_info=True，可以保证在时间数据在 copy 时保持原样。

      写入时间数据，则可通过此方法创建 excel 的时间对象：

      xlrd.xldate.xldate_from_datetime_tuple

      或者通过 xlwt.easyxf 指定时间格式：

      style = xlwt.easyxf(num_format_str='D-MMM-YY')

      ws.write(1, 0, datetime.now(), style)

      具体细节及更多功能这里不展开说明。

      以上便是 Python 操作 Excel 文件的一些基本方法。实际使用过程中遇到问题或者需要了解更多功能，永远记住两个词：

       

      RTFM、STFW ：）

    3. Python读excel，2003用xlrd，2007和2010用openpyxl

      xlrd介绍：http://pypi.python.org/pypi/xlrd

      转自：http://huaxia524151.iteye.com/blog/1173828

      安装

      有几种不同的安装方法。下面是以xlrd为例的，其它二个库都是使用同样的步骤。

      从源码安装

      Linux系统：

      Python代码  收藏代码
      1. $ tar xzf xlrd.tgz  
      2. $ cd xlrd-0.7.1  
      3. $ python setup.py install  

      Windows系统：使用WinZip或类似工具解压xlrd-0.7.1.zip：

      Python代码  收藏代码
      1. C:> cd xlrd-0.7.1  
      2. C:xlrd-0.7.1> Python26python setup.py install  

      注意：确保你想要在你的项目中使用python。

      使用Windows Installer安装

      Windows系统下，你可以下载运行xlrd-0.7.1.win32.exe安装。

      注意它只是以注册表形式安装到Python中。

      使用EasyInstall安装

      这种跨平台方法需要你已经安装了EasyInstall。更多信息请参考：

      http://peak.telecommunity.com/DevCenter/EasyInstall  

      Python代码  收藏代码
      1. easy_install xlrd  

      使用Buildout安装

      Buildout在遇见python包时依靠一个没有涉及到Python系统的项目，提供一种跨平台的方法。

      创建一个目录mybuildout，在里面下载下面文件：

      http://svn.zope.org/*checkout*/zc.buildout/trunk/bootstrap/bootstrap.py   

      现在，在mybuilout目录中创建一个名为buildout.cfg的文件，内容如下：

      Txt代码  收藏代码
      1. [buildout]  
      2. parts = py   
      3. versions = versions  
      4. [versions]  
      5. xlrd=0.7.1  
      6. xlwt=0.7.2  
      7. xlutils=1.3.2  
      8. [py]  
      9. recipe = zc.recipe.egg  
      10. eggs =   
      11.   xlrd   
      12.   xlwt   
      13.   xlutils  
      14. interpreter = py  

       注意：这个版本部分是可选的。

      最后，运行下面：

      Python代码  收藏代码
      1. $ python bootstrap.py  
      2. $ bin/buildout  

      这两行：

      • 初始化buildout环境
      • 运行buildout。 如果发生了变化这个命令每次都应该执行。

      Buildout主页在 http://pypi.python.org/pypi/zc.buildout

       读取Excel文件

      下面展示的所有的例子都是基于xlrd目录的教程。

      打开Workbooks

      Workbooks能从一个文件、一个mmap.mmap对象或一个字符串加载：

      Python代码  收藏代码
      1. from mmap import mmap,ACCESS_READ  
      2. from xlrd import open_workbook  
      3.   
      4. print open_workbook('simple.xls')  
      5.   
      6. with open('simple.xls','rb') as f:  
      7.     print open_workbook(  
      8.         file_contents=mmap(f.fileno(),0,acc  
      9.         )  
      10.   
      11. aString = open('simple.xls','rb').read()  
      12. print open_workbook(file_contents=aString)  

      操作Workbook 

      这是一个简单操作workbook的例子：

      Python代码  收藏代码
      1. from xlrd import open_workbook  
      2.   
      3. wb = open_workbook('simple.xls')  
      4.   
      5. for s in wb.sheets():  
      6.     print 'Sheet:',s.name  
      7.     for row in range(s.nrows):  
      8.         values = []  
      9.         for col in range(s.ncols):  
      10.             values.append(s.cell(row,col).value)  
      11.         print ','.join(values)  
      12.     print  

      下面几乎没有小节涉及到操作workbook的更多细节。

       揭秘Book

      通过open_workbook返回的xlrd.Book对象包含了所有对工作簿要的事情，能被用于在工作簿中取得独立的sheet。

      这个nsheets属性是一个整数，包含工作簿sheet的数量。这个属性与sheet_by_index方法结合起来是获取独立sheet最常用的方法。

      sheet_names方法返回包含工作簿中所有sheet名字的unicode列表。单独的sheet可以通过sheet_by_name方法使用这些名字获取。

      sheets方法的结果是迭代获取工作簿中的每个sheet。

      下面是这些方法和属性的例子示范：

      Python代码  收藏代码
      1. from xlrd import open_workbook  
      2.   
      3. book = open_workbook('simple.xls')  
      4.   
      5. print book.nsheets  
      6.   
      7. for sheet_index in range(book.nsheets):  
      8.     print book.sheet_by_index(sheet_index)  
      9.       
      10. print book.sheet_names()  
      11. for sheet_name in book.sheet_names():  
      12.     print book.sheet_by_name(sheet_name)  
      13.       
      14. for sheet in book.sheets():  
      15.     print sheet  

       xlrd.Book对象有与工作簿内容相关的其它属性，但很少用到：

      • codepage
      • countries
      • user_name

      如果你可能需要运用这些属性，请查看xlrd文档。

      揭秘Sheet

      通过上面介绍的方法返回的xlrd.sheet.Sheet对象包含了所有对worksheet和它的内容操作的信息。

      name属性是worksheet名字的unicode表示。

      nrows和ncols属性分别包含了worksheet中的行数和列数。

      下面例子展示了如何使用迭代来显示一个worksheet的内容：

      Python代码  收藏代码
      1. from xlrd import open_workbook,cellname  
      2.   
      3. book = open_workbook('odd.xls')  
      4. sheet = book.sheet_by_index(0)  
      5.   
      6. print sheet.name  
      7.   
      8. print sheet.nrows  
      9. print sheet.ncols  
      10.   
      11. for row_index in range(sheet.nrows):  
      12.     for col_index in range(sheet.ncols):  
      13.         print cellname(row_index,col_index),'-',  
      14.         print sheet.cell(row_index,col_index).value  

       xlrd.sheet.Sheet对象有其他一些与worksheet内容相关的属性，但很少使用：

      • col_label_ranges
      • row_label_ranges
      • visibility

      如果你认为你可能需要运用这些属性，请参看xlrd文档。

      获得特定的单元格

      正如你在前面例子中看到的，Sheet对象的cell方法能用来返回特定单元格的内容。

      cell方法返回一个xlrd.sheet.Cell对象。除了value包含了单元格的真实值，ctype包含了单元格的类型，Cell对象几乎没有其他属性。

      另外，Sheet对象有两个方法返回这两种数据类型。cell_value方法返回特定单元格的值，而cell_type方法返回特定单元格的类型。这两个方法执行时比获取Cell对象更快。

      后面会讲述更多Cell类型的细节。下面示范了这些方法，属性和起作用的类：

      Python代码  收藏代码
      1. from xlrd import open_workbook,XL_CELL_TEXT  
      2.   
      3. book = open_workbook('odd.xls')  
      4. sheet = book.sheet_by_index(1)  
      5.   
      6. cell = sheet.cell(0,0)  
      7. print cell  
      8. print cell.value  
      9. print cell.ctype==XL_CELL_TEXT  
      10.   
      11. for i in range(sheet.ncols):  
      12.     print sheet.cell_type(1,i),sheet.cell_value(1,i)  

       

      迭代Sheet的内容

      我们已经见过怎么迭代worksheet的内容，获取产生的单独的单元格。然而，有更容易的方法来获取单元格组。有一套对称的方法来通过行或列获取单元格组的信息。

      row和col方法分别返回一整行（列）的Cell对象。

      row_slice和col_slice方法分别返回一行（列）中以开始索引和一个可选的结束索引为边界的Cell对象列表。

      row_types和col_types方法分别返回一行（列）中以开始索引和一个可选的结束索引为边界的表示单元格类型的整数列表。

      row_values和col_values方法分别返回一行（列）中以开始索引和一个可选的结束索引为边界的表示单元格值的对象列表。

      下面是所有sheet迭代方法的示例：

      Python代码  收藏代码
      1. from xlrd import open_workbook  
      2.   
      3. book = open_workbook('odd.xls')  
      4. sheet0 = book.sheet_by_index(0)  
      5. sheet1 = book.sheet_by_index(1)  
      6.   
      7. print sheet0.row(0)  
      8. print sheet0.col(0)  
      9. print  
      10. print sheet0.row_slice(0,1)  
      11. print sheet0.row_slice(0,1,2)  
      12. print sheet0.row_values(0,1)  
      13. print sheet0.row_values(0,1,2)  
      14. print sheet0.row_types(0,1)  
      15. print sheet0.row_types(0,1,2)  
      16. print  
      17. print sheet1.col_slice(0,1)  
      18. print sheet0.col_slice(0,1,2)  
      19. print sheet1.col_values(0,1)  
      20. print sheet0.col_values(0,1,2)  
      21. print sheet1.col_types(0,1)  
      22. print sheet0.col_types(0,1,2)  

       

      实用方法

      当围绕workbook进行操作的时候，把行和列转换成用户习惯看到的Excel单元格引用（如：(0,0)转换成A1），这是很有用的。下面提供的方法帮助我们实现它：

      cellname方法把一对行和列索引转换为一个对应的Excel单元格引用。

      cellnameabs方法把一对行和列索引转换为一个绝对的Excel单元格引用（如：$A$1）。

      colname方法把一个列索引转换为Excel列名。

      下面是这三个方法的示例：

      Python代码  收藏代码
      1. from xlrd import cellname, cellnameabs, colname  
      2.   
      3. print cellname(0,0),cellname(10,10),cellname(100,100)  
      4. print cellnameabs(3,1),cellnameabs(41,59),cellnameabs(265,358)  
      5. print colname(0),colname(10),colname(100)  

       

      Unicode

      由xlrd产生的所有文本属性不是unidecode对象，就是ascii字符串（很少）。

      由Microsoft Excel输入的每个文本都是下列编码之一：

      • Latin1,如果匹配
      • UTF_16_LE，如果不匹配Latin1
      • 在更老的文件中，是按MS字符集规范编码的。他们由xlrd映射到Python编码，结果仍是unicode对象。

      其他知名软件用错误字符集或不用字符集写入Excel文件的情况是很少的。这种情况下，可能需要在open_workbook方法中指定正确的字符集。

      Python代码  收藏代码
      1. from xlrd import open_workbook  
      2. book = open_workbook('dodgy.xls',encoding='cp1252')  

       单元格的类型

      我们已经看过单元格类型用一个整数表示。这个整数相当于xlrd识别单元格类型的一组常数。可能的单元格类型在下面部分全部被列出来了。

      Text 文本

      这是由xlrd.XL_CELL_TEXT常数表示的。
      这种类型的单元格的值是unicode对象。

      Number 数字

      这是由xlrd.XL_CELL_NUMBER常数表示的。
      这种类型的单元格的值是float对象。

      Date 日期

      这是由xlrd.XL_CELL_DATE常数表示的。

      注意：日期在Excel文件中实际上是不存在的，它们只不过是特别格式化后的数字。

      如果数字格式字符串看起来像日期，xlrd将会返回xlrd.XL_CELL_DATE作为单元格类型。

      提供的xldate_as_tuple方法把日期单元格中的float数转化为适合实例化各种日期或时间对象的元组。这个例子展示了怎么使用它：

      Python代码  收藏代码
      1. from datetime import date,datetime,time  
      2. from xlrd import open_workbook,xldate_as_tuple  
      3.   
      4. book = open_workbook('types.xls')  
      5. sheet = book.sheet_by_index(0)  
      6.   
      7. date_value =  
      8. xldate_as_tuple(sheet.cell(3,2).value,book.datemode)  
      9. print datetime(*date_value),date(*date_value[:3])  
      10. datetime_value =  
      11. xldate_as_tuple(sheet.cell(3,3).value,book.datemode)  
      12. print datetime(*datetime_value)  
      13. time_value =  
      14. xldate_as_tuple(sheet.cell(3,4).value,book.datemode)  
      15. print time(*time_value[3:])  
      16. print datetime(*time_value)  

       说明：

      • Excel文件有两种可能的日期模式，一种用于最初由Windows创建的文件，一种用于最初由苹果电脑创建的文件。这个日期模式被表示成xlrd.Book对象的datemode属性，且必须传值给xldate_as_tuple方法。 
      • Excel文件格式对1904年一月3日以前的日期有各种问题，引起日期混乱，从而抛出XLDateError错误。 
      • Excel公式方法DATE()在某些情况下会返回出乎意料的日期。

      Boolean 布尔值

      这是由xlrd.XL_CELL_BOOLEAN常数表示的。
      这种单元格的值是bool对象。

      Error 错误

      这是由xlrd.XL_CELL_ERROR常数表示的。
      这种单元格的值是表示特定错误代码的整数。
      error_text_from_code方法用来把错误代码转换为错误信息：

      Python代码  收藏代码
      1. from xlrd import open_workbook,error_text_from_code  
      2.   
      3. book = open_workbook('types.xls')  
      4. sheet = book.sheet_by_index(0)  
      5.   
      6. print error_text_from_code[sheet.cell(5,2).value]  
      7. print error_text_from_code[sheet.cell(5,3).value]  

       对一种明显显示所有单元格类型的简单方法，参看xlutils.display。

      Empty/Blank 空值或空白

      Excel只是在单元格中存储信息，或者对单元格格式化。而xlrd是作为单元格的矩形网格表示。

      Excel文件中没有任何信息的单元格由xlrd.XL_CELL_EMPTY常数表示。另外，只要有一个空值，用于xlrd后整个值是空串，所以空值单元格应该使用一种Python标识检查。

      Excel文件中只有格式信息的单元格由xlrd.XL_CELL_BLANK常数表示，它的值总是一个空字符串。

      Python代码  收藏代码
      1. from xlrd import open_workbook,empty_cell  
      2.   
      3. print empty_cell.value  
      4.   
      5. book = open_workbook('types.xls')  
      6. sheet = book.sheet_by_index(0)  
      7. empty = sheet.cell(6,2)  
      8. blank = sheet.cell(7,2)  
      9. print empty is blank, empty is empty_cell, blank is empty_cell  
      10.   
      11. book = open_workbook('types.xls',formatting_info=True)  
      12. sheet = book.sheet_by_index(0)  
      13. empty = sheet.cell(6,2)  
      14. blank = sheet.cell(7,2)  
      15. print empty.ctype,repr(empty.value)  
      16. print blank.ctype,repr(blank.value)  

      下面例子展示了以上所有单元格类型一起的使用：

      Python代码  收藏代码
      1. from xlrd import open_workbook  
      2.   
      3. def cell_contents(sheet,row_x):  
      4. result = []  
      5. for col_x in range(2,sheet.ncols):  
      6. cell = sheet.cell(row_x,col_x)  
      7. result.append((cell.ctype,cell,cell.value))  
      8. return result  
      9.   
      10. sheet = open_workbook('types.xls').sheet_by_index(0)  
      11.   
      12. print 'XL_CELL_TEXT',cell_contents(sheet,1)  
      13. print 'XL_CELL_NUMBER',cell_contents(sheet,2)  
      14. print 'XL_CELL_DATE',cell_contents(sheet,3)  
      15. print 'XL_CELL_BOOLEAN',cell_contents(sheet,4)  
      16. print 'XL_CELL_ERROR',cell_contents(sheet,5)  
      17. print 'XL_CELL_BLANK',cell_contents(sheet,6)  
      18. print 'XL_CELL_EMPTY',cell_contents(sheet,7)  
      19.   
      20. print  
      21. sheet = open_workbook(  
      22. 'types.xls',formatting_info=True  
      23. ).sheet_by_index(0)  
      24.   
      25. print 'XL_CELL_TEXT',cell_contents(sheet,1)  
      26. print 'XL_CELL_NUMBER',cell_contents(sheet,2)  
      27. print 'XL_CELL_DATE',cell_contents(sheet,3)  
      28. print 'XL_CELL_BOOLEAN',cell_contents(sheet,4)  
      29. print 'XL_CELL_ERROR',cell_contents(sheet,5)  
      30. print 'XL_CELL_BLANK',cell_contents(sheet,6)  
      31. print 'XL_CELL_EMPTY',cell_contents(sheet,7)  

       

      Names

      这些是很少使用但很强大的抽象方法，常用于查找Excel文件的内部信息。

      它们有很多用途，xlrd能从它们之中获取信息。一个值得注意的例外是与sheet和宏命令相关的信息将会被忽略。

      Names在Excel中是通过Insert > Name > Define操作创建的。如果你想使用xlrd来从Names中获取信息，在你选择的电子表格应用程序中精通names的定义和运用是一个不错的想法。

      Types 类型

      一个Name可以涉及到：

      • 一个常数

      CurrentInterestRate = 0.015
      NameOfPHB = “Attila T. Hun”

      • 一个单元格的绝对引用

      CurrentInterestRate = Sheet1!$B$4

      • 一个单元格的1D，2D或3D块的绝对引用

      MonthlySalesByRegion = Sheet2:Sheet5!$A$2:$M$100

      • 一个绝对引用的列表

      Print_Titles = [row_header_ref, col_header_ref])

      常数可以被获取。

      绝对引用的坐标可以被获取，以便你稍后获取相关sheet的对应数据。

      相对引用只有当你很熟悉被作为起源使用的单元格时是有用的。Excel文件中包含函数调用在内的公式和多重引用并不是有用的，也太难而无法评估。

      xlrd中没有包含全部的计算引擎。

      Scope 范围

      一个Name的Score可以是全局的，或者它只针对特定的sheet。一个Name的标识符在不同Scope内可以被重用。但有多个相同标识符的Name，根据scope使用最合适的一个。一个好例子是内置名为Print_Area；每个worksheet都可能有它们中的一个。

      例：
      name=rate, scope=Sheet1, formula=0.015
      name=rate, scope=Sheet2, formula=0.023
      name=rate, scope=global, formula=0.040

      一个单元格公式(1+rate)^20出现在Sheet1等价于1.015^20，出现在Sheet2等价于1.023^20，出现在其他Sheet等价于1.040^20。

      惯例

      使用names的一般原因包括：

      • 一个workbook中可能多个地方出现的值设定文本名称。如：RATE = 0.015
      • 容易被错误复制的复杂公式设定文本名称。如：SALES_RESULTS = $A$10:$M$999

      这里有个真实世界的案例：向总部报告。一个公司的总部制作了一个模版workbook。每个部门复制一份并填充内容。所有被提供的日期范围都定义了Names。当这些文件传回时，一个脚本用于验证这个部门是否损坏了这个workbook，这个Names用于获取数据来做进一步处理。使用names可以将这些范围解耦和，不管是总部设计模版的用户还是往模版里填充内容的部门用户 从这个脚本都只知道这些范围的names，而不知道具体的范围值。

      在xlrd发布的examples目录中你会找到namesdemo.xls，有许多例子，大部分都是针对非苹果系统定义的names。也有个xlrdnamesAPIdemo.py文件展示了如何使用name查找字典，如何获取常数、引用和引用指向的数据。

      格式化

      我们已经看到open_workbook方法有个参数从Excel文件加载信息。当这步完成，所有格式化信息都是可获得的，但是它是怎么实现的细节不再本书的范围内。

      如果你想要复制格式化后的数据到一个新Excel文件中，参看xlutils.copy和xlutils.filter。

      如果你想要检测格式化信息，你需要参考下面类的属性：

      xlrd.Book

      colour_map         font_list                format_list        format_map
      palette_record   style_name_map   xf_list

      xlrd.sheet.Sheet

      cell_xf_index       rowinfo_map        colinfo_map       computed_column_width
      default_additional_space_above                              default_additional_space_below
      default_row_height                                                  default_row_height_mismatch
      default_row_hidden                                                 defcolwidth
      gcw                                                                           merged_cells

      standard_width

      xlrd.sheet.Cell

      xf_index

      Other Classes

      另外，下面类是只用于表示格式化的信息：
      xlrd.sheet.Rowinfo
      xlrd.sheet.Colinfo
      xlrd.formatting.Font
      xlrd.formatting.Format
      xlrd.formatting.XF
      xlrd.formatting.XFAlignment
      xlrd.formatting.XFBackground
      xlrd.formatting.XFBorder
      xlrd.formatting.XFProtection

      操作大的Excel文件

      如果你在操作特别大的Excel文件，那么有两个你应该注意的xlrd特性：

      • open_workbook方法的on_demand参数为True，被访问时会导致只往内存里加载worksheet。
      • xlrd.Book对象有一个unload_sheet方法能通过指定sheet索引或sheet名称从内存中卸载worksheet。

      下面的例子展示了一个大的workbook怎么去迭代被检查只匹配某一模式的sheet，并在内存中某个时间被卸载。

      Python代码  收藏代码
      1. from xlrd import open_workbook  
      2.   
      3. book = open_workbook('simple.xls',on_demand=True)  
      4.   
      5. for name in book.sheet_names():  
      6.     if name.endswith('2'):  
      7.         sheet = book.sheet_by_name(name)  
      8.         print sheet.cell_value(0,0)  
      9.         book.unload_sheet(name)  

       
      用runxlrd.py揭秘Excel文件

      xlrd源码发布包括runxlrd.py脚本，它是非常有用的，不用写单行Python就能揭秘Excel文件。

      推荐运行教材提供的各种命令操作Excel文件。

      下面是从runxlrd获得的一个预览，使用python runxlrd.py --help能得到：

      Python代码  收藏代码
      1. runxlrd.py [options] command [input-file-patterns]  
      2.   
      3. Commands:  
      4.   
      5. 2rows           Print the contents of first and last row in each sheet  
      6. 3rows           Print the contents of first, second and last row in each sheet  
      7. bench           Same as "show", but doesn't print -- for profiling  
      8. biff_count[1]   Print a count of each type of BIFF record in the file  
      9. biff_dump[1]    Print a dump (char and hex) of the BIFF records in the file  
      10. fonts           hdr + print a dump of all font objects  
      11. hdr             Mini-overview of file (no per-sheet information)  
      12. hotshot         Do a hotshot profile run e.g. ... -f1 hotshot bench bigfile*.xls  
      13. labels          Dump of sheet.col_label_ranges and ...row... for each sheet  
      14. name_dump       Dump of each object in book.name_obj_list  
      15. names           Print brief information for each NAME record  
      16. ov              Overview of file  
      17. profile         Like "hotshot", but uses cProfile  
      18. show            Print the contents of all rows in each sheet  
      19. version[0]      Print versions of xlrd and Python and exit  
      20. xfc             Print "XF counts" and cell-type counts -- see code for details  
      21.   
      22. [0] means no file arg  
      23. [1] means only one file arg i.e. no glob.glob pattern  
      24.   
      25. Options:  
      26.   -h, --help            show this help message and exit  
      27.   -l LOGFILENAME, --logfilename=LOGFILENAME  
      28.                         contains error messages  
      29.   -v VERBOSITY, --verbosity=VERBOSITY  
      30.                         level of information and diagnostics provided  
      31.   -p PICKLEABLE, --pickleable=PICKLEABLE  
      32.                         1: ensure Book object is pickleable (default); 0:  
      33.                         don't bother  
      34.   -m MMAP, --mmap=MMAP  1: use mmap; 0: don't use mmap; -1: accept heuristic  
      35.   -e ENCODING, --encoding=ENCODING  
      36.                         encoding override  
      37.   -f FORMATTING, --formatting=FORMATTING  
      38.                         0 (default): no fmt info 1: fmt info (all cells)  
      39.   -g GC, --gc=GC        0: auto gc enabled; 1: auto gc disabled, manual  
      40.                         collect after each file; 2: no gc  
      41.   -s ONESHEET, --onesheet=ONESHEET  
      42.                         restrict output to this sheet (name or index)  
      43.   -u, --unnumbered      omit line numbers or offsets in biff_dump  

      python操作Excel读写--使用xlrd

      一、安装xlrd模块

         到python官网下载http://pypi.python.org/pypi/xlrd模块安装，前提是已经安装了python 环境。

      二、使用介绍

        1、导入模块

            import xlrd

         2、打开Excel文件读取数据

             data = xlrd.open_workbook('excelFile.xls')

         3、使用技巧

              获取一个工作表

              table = data.sheets()[0]          #通过索引顺序获取
       
              table = data.sheet_by_index(0) #通过索引顺序获取
              table = data.sheet_by_name(u'Sheet1')#通过名称获取
       
              获取整行和整列的值（数组）
       　　
               table.row_values(i)
       
               table.col_values(i)
       
              获取行数和列数
      　　
              nrows = table.nrows
       
              ncols = table.ncols
             
              循环行列表数据
              for i in range(nrows ):
            print table.row_values(i)
       
      单元格
      cell_A1 = table.cell(0,0).value
       
      cell_C4 = table.cell(2,3).value
       
      使用行列索引
      cell_A1 = table.row(0)[0].value
       
      cell_A2 = table.col(1)[0].value
       
      简单的写入
      row = 0
       
      col = 0
       
      # 类型 0 empty,1 string, 2 number, 3 date, 4 boolean, 5 error
      ctype = 1 value = '单元格的值'
       
      xf = 0 # 扩展的格式化
       
      table.put_cell(row, col, ctype, value, xf)
       
      table.cell(0,0)  #单元格的值'
       
      table.cell(0,0).value #单元格的值'
       

      三、Demo代码

         Demo代码其实很简单，就是读取Excel数据。

         

      复制代码
       1 # -*- coding: utf-8 -*- 
 2 import  xdrlib ,sys
 3 import xlrd
 4 def open_excel(file= 'file.xls'):
 5     try:
 6         data = xlrd.open_workbook(file)
 7         return data
 8     except Exception,e:
 9         print str(e)
10 #根据索引获取Excel表格中的数据   参数:file：Excel文件路径     colnameindex：表头列名所在行的所以  ，by_index：表的索引
11 def excel_table_byindex(file= 'file.xls',colnameindex=0,by_index=0):
12     data = open_excel(file)
13     table = data.sheets()[by_index]
14     nrows = table.nrows #行数
15     ncols = table.ncols #列数
16     colnames =  table.row_values(colnameindex) #某一行数据 
17     list =[]
18     for rownum in range(1,nrows):
19 
20          row = table.row_values(rownum)
21          if row:
22              app = {}
23              for i in range(len(colnames)):
24                 app[colnames[i]] = row[i] 
25              list.append(app)
26     return list
27 
28 #根据名称获取Excel表格中的数据   参数:file：Excel文件路径     colnameindex：表头列名所在行的所以  ，by_name：Sheet1名称
29 def excel_table_byname(file= 'file.xls',colnameindex=0,by_name=u'Sheet1'):
30     data = open_excel(file)
31     table = data.sheet_by_name(by_name)
32     nrows = table.nrows #行数 
33     colnames =  table.row_values(colnameindex) #某一行数据 
34     list =[]
35     for rownum in range(1,nrows):
36          row = table.row_values(rownum)
37          if row:
38              app = {}
39              for i in range(len(colnames)):
40                 app[colnames[i]] = row[i]
41              list.append(app)
42     return list
43 
44 def main():
45    tables = excel_table_byindex()
46    for row in tables:
47        print row
48 
49    tables = excel_table_byname()
50    for row in tables:
51        print row
52 
53 if __name__=="__main__":
54     main()
      复制代码
       

      django中的写法：

      [python] view plain copy
       
      1. file_obj = request.FILES.get('uploadcsv','')  
      2.   
      3. 的是XLS文件             
      4.  import xlrd  
      5.            #1.读取XLS内容  
      6.            bk = xlrd.open_workbook(file_contents = file_obj.read())  
      7.            #2.或者是告诉它文件路径,如下  
      8.            #bk = xlrd.open_workbook(path/to/xls)  
      9.            try:#看是不是XLS的第一张表  
      10.                sh = bk.sheet_by_index(0)  
      11.            except:  
      12.                return render_to_response('admins/message.html',{'message':'没有读取到您的第一张表!'},context_instance=template.RequestContext(request))  
      13.            #计算文件的总行数  
      14.            nrows = sh.nrows  
      15.            reader = []  
      16.            #再循环将每一行的数据写进一个LIST中备用  
      17.            for i in range(nrows):  
      18.                row_data = sh.row_values(i)  
      19.                reader.append(row_data)  
      20.   
      21. #如果传入的是CSV文件  
      22.            import StringIO,csv  
      23.            data = StringIO.StringIO(file_obj.read())  
      24.            try:  
      25.                reader = csv.reader(data)  
      26.            except Exception,e:  
      27.                return render_to_response('admins/message.html',{'message':'CSV文件没有正常读取，请重新检查后上传！2'},context_instance=template.RequestContext(request))   
      28.   
      29. ader这个列表，读出每个数据即可          

      python 使用openpyxl 读写xlsx

      转自：http://hi.baidu.com/chapsticks/item/773f7ae573b34f3f4ddcaf5a

      python有很多模块都是用来操作excel的，比如xlrd，xlwt，pyExcelerator。用着很方便，但是问题是，只能支持到excel2003。虽然一般的应用其实足够了，但是如果遇到了导出大量数据（超过65535条）的需求时，excel2003就不够用了。所以我就只好去找一个能支持excel2007的模块。

      google了一下，发现了这个openpyxl，不过网上也没什么中文的文档可以看，于是就自己琢磨琢磨。

      I.安装

      openpyxl的最新版本是1.5.0 下载地址 http://pypi.python.org/pypi/openpyxl/1.5.0

      需求python的版本是2.6+ ，也就是说，如果centOS系统的机器想用，那得升级系统的python。。。

      安装就是解压缩，然后cd到目录，然后

      python setup.py install （安装）

      II.读取excel2007文件

      http://packages.python.org/openpyxl/usage.html（openpyxl使用例子）

      view plaincopy to clipboardprint?

      1. #-*- coding:utf-8 -* 

      2. 

      3. from openpyxl.reader.excel import load_workbook 

      4. import MySQLdb 

      5. import time 

      6. 

      7. #开始时间 

      8. startTime = time.time() 

      9. 

      10. #读取excel2007文件 

      11. wb = load_workbook(filename = r'empty_book.xlsx') 

      12. 

      13. #显示有多少张表 

      14. print "Worksheet range(s):", wb.get_named_ranges() 

      15. print "Worksheet name(s):", wb.get_sheet_names() 

      16. 

      17. #取第一张表 

      18. sheetnames = wb.get_sheet_names() 

      19. ws = wb.get_sheet_by_name(sheetnames[0]) 

      20. 

      21. #显示表名，表行数，表列数 

      22. print "Work Sheet Titile:",ws.title 

      23. print "Work Sheet Rows:",ws.get_highest_row() 

      24. print "Work Sheet Cols:",ws.get_highest_column() 

      25. 

      26. 

      27. # 建立存储数据的字典 

      28. data_dic = {} 

      29. 

      30. #把数据存到字典中 

      31. for rx in range(ws.get_highest_row()): 

      32. 

      33. temp_list = [] 

      34. pid = ws.cell(row = rx,column = 0).value 

      35. w1 = ws.cell(row = rx,column = 1).value 

      36. w2 = ws.cell(row = rx,column = 2).value 

      37. w3 = ws.cell(row = rx,column = 3).value 

      38. w4 = ws.cell(row = rx,column = 4).value 

      39. temp_list = [w1,w2,w3,w4] 

      40. 

      41. data_dic[pid] = temp_list 

      42. 

      43. #打印字典数据个数 

      44. print 'Total:%d' %len(data_dic) 

      注意的是ws.cell()方法，支持的参数有两种，cell（coordinate=None, row=None,column=None）

      coordinate坐标，eg ws.cell("B1") 

      row 和 column 是行和列 ，都是从0开始

      还有，如果想取得格里的值，得用ws.cell("A1").value 取到，如果用过xlrd，因为写法差不多，可能就会忘记加value了。

      III.写入excel2007

      view plaincopy to clipboardprint?

      1. 写excel2007 

      2. 

      3. #-*- coding:utf-8 -* 

      4. 

      5. 

      6. import MySQLdb 

      7. import time 

      8. import sys 

      9. #workbook相关 

      10. from openpyxl.workbook import Workbook 

      11. #万恶的ExcelWriter，妹的封装好了不早说，封装了很强大的excel写的功能 

      12. from openpyxl.writer.excel import ExcelWriter 

      13. #一个eggache的数字转为列字母的方法 

      14. from openpyxl.cell import get_column_letter 

      15. 

      16. 

      17. #新建一个workbook 

      18. 

      19. wb = Workbook() 

      20. #新建一个excelWriter 

      21. ew = ExcelWriter(workbook = wb) 

      22. 

      23. #设置文件输出路径与名称 

      24. dest_filename = r'empty_book.xlsx' 

      25. 

      26. #第一个sheet是ws 

      27. ws = wb.worksheets[0] 

      28. 

      29. #设置ws的名称 

      30. ws.title = "range names" 

      31. 

      32. 

      33. #录入数据，注意col是数字转字母，然后需要限定%s（string型）当参数传到ws.cell()方法中去,records可以想象为一个从数据库里查询出来的数据集合 

      34. i=1 

      35. table = {} 

      36. for record in records: 

      37. for x in range(1,len(record)+1): 

      38. col = get_column_letter(x) 

      39. ws.cell('%s%s'%(col, i)).value = '%s' % (record[x-1]) 

      40. 

      41. i+=1 

      42. 

      43. #又建了一个sheet，ws名字都没变，太省了。。。但是确实是一个新的sheet，不会影响之前那个sheet的东西 

      44. ws = wb.create_sheet() 

      45. 

      46. ws.title = 'Pi' 

      47. 

      48. ws.cell('F5').value = 3.14 

      49. 

      50. 

      51. #写文件 

      52. ew.save(filename = dest_filename) 

      注意的地方：

      # col是用列号x为参数，调用了这个模块的get_column_letter方法算出来的字母，这个比较蛋疼。

      col = get_column_letter(x) 

      #在为数据格赋值的时候，注意写的格式：要不会有各种不靠谱的问题出现（这个是用坐标的方式写的，其实用row ，col的方式可能没那么麻烦）

      ws.cell('%s%s'%(col, i)).value = '%s' % (record[x-1]) 

      关于该模块的API 可以查询官方文档 http://packages.python.org/openpyxl/api.html

      总体来说，这个模块还是挺方便的，但是问题就是在对于python的版本有一定要求，如果在centOs上用，可能会有些问题。
  • 相关阅读:
    GridView合并表头多重表头
    C# 导出Excel或Word
    GridView的分页功能?
    如何在GridView中判断Radio被选中?
    GridView無數據時，顯示表頭
    Oracle replace函数使用
    获取数据后导出Excel
    Oracel用rownum实现真分页
    转载C#泛型集合—Dictionary<K,V>使用技巧
    临时向表插入有自增的字段的记录
  • 原文地址：https://www.cnblogs.com/think-and-do/p/6357915.html
Copyright © 2020-2023  润新知