#Sunsol (‪中文(中国大陆)‬)

   free wysiwyg wiki

Tpip 224

出自Sunsol

   跳转到: 导航, 搜索

目录

     * 1 主题 -- 加密
          + 1.1 模块 -- crypt : 创建和验证Unix风格的密码
               o 1.1.1 函数：
          + 1.2 模块 -- md5 : 创建MD5校验码
               o 1.2.1 常数：
               o 1.2.2 类：
               o 1.2.3 方法：
          + 1.3 模块 -- rotor : 恩尼格玛密码机
               o 1.3.1 类：
               o 1.3.2 方法：
          + 1.4 模块 -- sha : SHA安全散列算法
               o 1.4.1 类：
               o 1.4.2 方法：
     * 2 主题 -- 压缩
          + 2.1 模块 -- gzip : 处理gzip压缩文件
               o 2.1.1 类：
               o 2.1.2 方法和属性：
          + 2.2 模块 -- zipfile : 读写ZIP文件
               o 2.2.1 常数：
               o 2.2.2 函数：
               o 2.2.3 类：
               o 2.2.4 方法和属性：
               o 2.2.5 异常：
          + 2.3 模块--zlib:压缩和解压的zlib库
               o 2.3.1 常数：
               o 2.3.2 函数：
               o 2.3.3 方法和属性：
               o 2.3.4 异常：

[编辑] 主题 -- 加密

          Python的标准库里没有一般的加密模块，只提供了少数几个功能有限的加密算法，包括若干哈希加密和一个弱对称加密算法。这里列出一些常用的加密技术：

          + 对称加密:* 源文本M由一个密匙K产生加密文本C，密匙K也可以用来解密文本C还原成源文本M。[rotor]模块提供了一个不是特别可靠的对称加密应用。
          + 哈希加密:* 是一种从源文本M生成一个较短的哈希值H的技术，其具有以下几个特点：只有H很难获得可以生成H的文本M'，不同的两个文本M和M'生成的两个H只有极小的可能情况下才会相同。文本M'生成的H'和H之间没有什么关系，基本上无法从此推导出源文本M。模块[crypt], [md5]和[sha]提供了一些哈希加密算法。
          + 非对称加密:* 又叫做公匙加密。加密过程中使用一对密匙K{公}和K{私}。非对称加密的算法是P(M,K)。对于源文本M而言，其相当于P(K{私},P(M,K{公}))。只有公匙K{公}是很难通过前面这个公式获得私匙K{私}的。同样只有加密文本P(M,K{公})也很难获得源文本M。通常在非对称加密系统里会生成K{公}和K{私}，然后给其他用户K{公}自己保留K{私}。标准库里没有这方面的功能。
          + 数字签名:* 数字签名实际上是一种反转的公匙加密。在很多情况下二者采用同样的算法。数字签名包括一对密匙K{验证}和K{签名}。验证算法是S(M,K)，对于任何信息M而言，M等于S(K{验证},S(M,K{签名}))。只有K{验证}是很难通过前面的公式获得K{签名}的。只有签名信息S(M,K{签名})是很难伪造出同样签名的其他信息。通常在数字签名系统中用户公布K{验证}给其他用户，自己保留K{签名}。标准库里没有这方面的功能。

          -*-
          这些都是最主要的加密技术。更详细的密码介绍资料可以在作者的网站上找到。基础教材是_加密的概念一_：
          [1]
          进一步的教材是_加密的概念二_：
          [2]
          最后是_加密协议_：
          [3]
          有些第三方模块库可以处理加密任务，相关的介绍在[4]。这些都涉及到具体细节，基本和文字处理关系不大。此外，有些第三方工具库往往需要依赖一些其他的非Python的库文件，有些只适合部分平台，同时这些工具不一定能提供Python新版本可用的库文件。
          下面列出一些比较常用的第三方加密模块。

          + mxCrypto
          + amkCrypto

          [mxCrypto]和[amkCrypto]是最为通用的，相关库文件在：
          [5]
          这些加密模块的文档资料在：
          [6]

          + M2Crypto
          + M2Crypto

          [mxCrypto]和[amkCrypto]模块主要用于Unix平台。类似的Windows平台可以使用的是[M2Crypto]。资料和文件在：
          [7]

          + fcrypt

          [fcrypt]是纯Python的模块。但在效率上可能不太好：
          [8]

[编辑] 模块 -- crypt : 创建和验证Unix风格的密码

          函数'crypt()'是一个常用的但有些陈旧的加密验证工具。在Unix系统中，'crypt()'只是系统库功能的Python封装。'crypt()'的加密形式主要基于DES。[crypt]模块只有安装在类Unix系统的Python里才有，该模块依赖于基本系统库。第三方[fcrypt]模块提供了同样的功能，不过是由纯Python实现的。

[编辑] 函数：

          + crypt.crypt(passwd, salt)

          返回13个字节的ASCII密码。参数'passwd'必须是至少8个字符长度的字符串。参数'salt'必须是至少两个字符的字符串。

     >>> from crypt import crypt
     >>> crypt('mypassword','XY')
     'XY5XuULXk4pcs'
     >>> crypt('mypasswo','XY')
     'XY5XuULXk4pcs'
     >>> crypt('mypassword...more.characters','XY')
     'XY5XuULXk4pcs'
     >>> crypt('mypasswo','AB')
     'AB06lnfYxWIKg'
     >>> crypt('diffpass','AB')
     'ABlO5BopaFYNs'

          参考： `fcrypt`, [md5], [sha]

[编辑] 模块 -- md5 : 创建MD5校验码

          MD5哈希算法是一种被广泛使用的加密算法。和[crypt]不同的是，[md5]可以用于任意字符串（但不包括Unicode字符串）。如果不考虑的兼容性和其他一些因素的话，使用SHA要比MD5好，[sha]模块提供了这个算法。使用[md5]的方法类似`binascii.crc32()`，产生的哈希值可以通过循环逐步获得最后需要的字符串。MD5算法产生的是128位哈希校验码。

[编辑] 常数：

          + md5.MD5Type

          标示对象使用的算法是MD5。

[编辑] 类：

          + md5.new([s])

          创建[md5]对象。

     >>> import md5
     >>> md5.new('Mary had a little lamb').hexdigest()
     'e946adb45d4299def2071880d30136d4'

          + md5.md5([s])

          和`md5.new`一样。

[编辑] 方法：

          + md5.copy()

          复制一份新的[md5]对象。

     >>> import md5
     >>> m = md5.new('spam and eggs')
     >>> m.digest()
     '\xb5\x81f\x0c\xff\x17\xe7\x8c\x84\xc3\xa8J\xd0.g\x85'
     >>> m2 = m.copy()
     >>> m2.digest()
     '\xb5\x81f\x0c\xff\x17\xe7\x8c\x84\xc3\xa8J\xd0.g\x85'
     >>> m.update(' are tasty')
     >>> m2.update(' are wretched')
     >>> m.digest()
     '*\x94\xa2\xc5\xceq\x96\xef&\x1a\xc9#\xac98\x16'
     >>> m2.digest()
     'h\x8c\xfam\xe3\xb0\x90\xe8\x0e\xcb\xbf\xb3\xa7N\xe6\xbc'

          + md5.digest()

          返回128位哈希校验码即16个字节的字符串。

     >>> import md5          # Python 2.1+
     >>> m = md5.new('spam and eggs')
     >>> m.digest()
     '\xb5\x81f\x0c\xff\x17\xe7\x8c\x84\xc3\xa8J\xd0.g\x85'

     >>> import md5          # Python <= 2.0
     >>> m = md5.new('spam and eggs')
     >>> m.digest()
     '\265\201f\014\377\027\347\214\204\303\250J\320.g\205'

          + md5.hexdigest()

          以十六进制编码形式返回128位哈希校验码。

     >>> import md5
     >>> m = md5.new('spam and eggs')
     >>> m.hexdigest()
     'b581660cff17e78c84c3a84ad02e6785'

          + md5.update(s)

          增加后续字符串。类似CRC循环校验。

     >>> import md5
     >>> m1 = md5.new('spam and eggs')
     >>> m2 = md5.new('spam')
     >>> m2.update(' and eggs')
     >>> m3 = md5.new('spam')
     >>> m3.update(' and ')
     >>> m3.update('eggs')
     >>> m1.hexdigest()
     'b581660cff17e78c84c3a84ad02e6785'
     >>> m2.hexdigest()
     'b581660cff17e78c84c3a84ad02e6785'
     >>> m3.hexdigest()
     'b581660cff17e78c84c3a84ad02e6785'

          参考： [sha], [crypt], `binascii.crc32()`

[编辑] 模块 -- rotor : 恩尼格玛密码机

          在Python标准库里[rotor]模块是为数不多的几个有趣模块之一（2.4中移除）。关于这个密码机的故事可以到网上搜索，估计是因为它和图灵的关系才被纳入标准库。

[编辑] 类：

          + rotor.newrotor(key [,numrotors])

          产生转子。参数'numrotors'用于指定转子的数量，默认为6。

     >>> rotor.newrotor('mypassword').encrypt('Mary had a lamb')
     '\x10\xef\xf1\x1e\xeaor\xe9\xf7\xe5\xad,r\xc6\x9f'

          加密和解密过程如下：

     >>> import rotor
     >>> C = rotor.newrotor('pass2').encrypt('Mary had a little lamb')
     >>> r1 = rotor.newrotor('mypassword')
     >>> C2 = r1.encrypt('Mary had a little lamb')
     >>> r1.decrypt(C2)
     'Mary had a little lamb'
     >>> r1.decrypt(C)   # Let's try it
     '\217R$\217/sE\311\330~#\310\342\200\025F\221\245\263\036\220O'
     >>> r1.setkey('pass2')
     >>> r1.decrypt(C)   # Let's try it
     'Mary had a little lamb'

[编辑] 方法：

          + rotor.decrypt(s)

          解密。

          + rotor.decryptmore(s)

          解密后续字符串，保持之前解密时的转子状态。

          + rotor.encrypt(s)

          加密。

          + rotor.encryptmore(s)

          加密后续字符串，保持之前解密时的转子状态。

          + rotor.setkey(key)

          设新的密匙。

[编辑] 模块 -- sha : SHA安全散列算法

          美国国家标准与技术研究所的安全散列算法是目前应用最好的哈希加密算法。同[md5]一样，[sha]可以用于任意字符串（但不包括Unicode字符串）。SHA要好于MD5算法。[sha]的使用方法类似`binascii.crc32()`。算法产生的是160位哈希特征值。

[编辑] 类：

          + sha.new([s])

          创建[sha]对象。

     >>> import sha
     >>> sha.new('Mary had a little lamb').hexdigest()
     'bac9388d0498fb378e528d35abd05792291af182'

          + sha.sha([s])

          同`sha.new`。

[编辑] 方法：

          + sha.copy()

          复制一份新的[sha]对象。

     >>> import sha
     >>> s = sha.new('spam and eggs')
     >>> s.digest()
     '\276\207\224\213\255\375x\024\245b\036C\322\017\2528 @\017\246'
     >>> s2 = s.copy()
     >>> s2.digest()
     '\276\207\224\213\255\375x\024\245b\036C\322\017\2528 @\017\246'
     >>> s.update(' are tasty')
     >>> s2.update(' are wretched')
     >>> s.digest()
     '\013^C\366\253?I\323\206nt\2443\251\227\204-kr6'
     >>> s2.digest()
     '\013\210\237\216\014\3337X\333\221h&+c\345\007\367\326\274\321'

          + sha.digest()

          返回160位哈希校验码即20个字节的字符串。

     >>> import sha          # Python 2.1+
     >>> s = sha.new('spam and eggs')
     >>> s.digest()
     '\xbe\x87\x94\x8b\xad\xfdx\x14\xa5b\x1eC\xd2\x0f\xaa8 @\x0f\xa6'

     >>> import sha          # Python <= 2.0
     >>> s = sha.new('spam and eggs')
     >>> s.digest()
     '\276\207\224\213\255\375x\024\245b\036C\322\017\2528 @\017\246'

          + sha.hexdigest()

          以十六进制编码形式返回校验码。

     >>> import sha
     >>> s = sha.new('spam and eggs')
     >>> s.hexdigest()
     'be87948badfd7814a5621e43d20faa3820400fa6'

          + sha.update(s)

          增加后续字符串。类似CRC循环校验。

     >>> import sha
     >>> s1 = sha.sha('spam and eggs')
     >>> s2 = sha.sha('spam')
     >>> s2.update(' and eggs')
     >>> s3 = sha.sha('spam')
     >>> s3.update(' and ')
     >>> s3.update('eggs')
     >>> s1.hexdigest()
     'be87948badfd7814a5621e43d20faa3820400fa6'
     >>> s2.hexdigest()
     'be87948badfd7814a5621e43d20faa3820400fa6'
     >>> s3.hexdigest()
     'be87948badfd7814a5621e43d20faa3820400fa6'

          参考： [md5], [crypt], `binascii.crc32()`

[编辑] 主题 -- 压缩

          在计算机的历史上已经发明了大量的数据压缩格式，大都采用的是LZ编码或哈夫曼编码技术。压缩在各个方面都有应用，文件压缩是使用最广泛的。在MS-DOS和Windows里我们经常看到ARC,PAK,ZOO,LHA,ARJ,CAB,RAR等等压缩格式，但最常见的还是ZIP格式。在Unix系统里大多也是gzip格式，不过bzip的压缩率更好一些。在MacOS中最流行的格式是SIT。其他平台也有很多压缩格式，但ZIP格式基本上是所有平台都支持的一种压缩格式。
          Python标准库包括了一些压缩模块。在[zlib]模块中主要针对的是底层字符串数据压缩，并不直接对文件操作。[zlib]本身也被其他高一级的模块使用。
          [gzip]和[zipfile]提供的是压缩文件接口。[gzip]和[zipfile]的主要不同是格式上的差异，一个是GZ格式一个是ZIP格式。'gzip'用于操作单一文件就像归档工具'tar'，特别是Unix系统中的类似'foo.tgz'或'foo.tar.gz'等就是由'tar'归档以后再作'gzip'压缩后的文件。ZIP则是同时作压缩和归档的处理。正因如此，[gzip]可以直接操作GZ文件。[ziplib]提供了更为专业的压缩操作如浏览压缩文件包含的内容或专用的图像压缩等等。
          数据压缩的介绍请参考附录B。

[编辑] 模块 -- gzip : 处理gzip压缩文件

          [gzip]模块可以直接操作'gzip'文件。压缩数据可以读出也可以写入，所有的这些读写操作都会自动解压或压缩。下面是个简单的例子：

     #---------- gzip_file.py ----------#
     # GZ文件和其他一般文件基本上操作方式没有区别
     import gzip, glob
     print "Size of data in files:"
     for fname in glob.glob('*'):
         try:
             if fname[-3:] == '.gz':
                 s = gzip.open(fname).read()
             else:
                 s = open(fname).read()
             print ' ',fname,'-',len(s),'bytes'
         except IOError:
             print 'Skipping',file

          模块[gzip]对[zlib]进行了包装，主要是由后者来做实际的压缩和解压处理。在许多方面，[gzip]就像[mmap]和[StringIO]一样处理的是类文件对象。
          参考： [mmap], [StringIO], [cStringIO]

[编辑] 类：

          + gzip.GzipFile([filename=... [,mode="rb" [,compresslevel=9 [,fileobj=...]]]])

          创建[gzip]文件对象。这个对象支持大多数文件对象操作，除了不能使用'.seek()'和'.tell()'。
          参数'mode'默认为'rb'('r','rb','a','ab','w'或'wb')。参数'compresslevel'指定了压缩的级别。默认为最高级别9，级别1基本上没有太多的压缩，但运行速度快。参数'fileobj'如果指定，则'filename'和'mode'采用这个指定文件对象的属性。

          + gzip.open(filename=... [mode='rb [,compresslevel=9]])

          类似`gzip.GzipFile`，但没有了文件对象参数。一般对GZ文件操作都是使用文件名来指定操作的文件，而不是用文件对象。

[编辑] 方法和属性：

          + gzip.close()

          关闭[gzip]对象。如果是基于文件对象建立的'gzip'对象，则关闭时不会关闭原文件对象。
          参考： `FILE.close()`

          + gzip.flush()

          将所有更动写入磁盘。
          参考： `FILE.close()`

          + gzip.isatty()

          返回0。这是为了兼容文件对象。
          参考： `FILE.isatty()`

          + gzip.myfileobj

          基本文件对象。

          + gzip.read([num])

          和`FILE.read()`一样。
          参考： `FILE.read()`

          + gzip.readline([length])

          和`FILE.readline()`一样。
          参考： `FILE.readline()`

          + gzip.readlines([sizehint=...])

          和`FILE.readlines()`一样。
          参考： `FILE.readlines()`

          + gzip.write(s)

          和`FILE.write()`一样。
          参考： `FILE.write()`

          + gzip.writelines(list)

          类似`FILE.writelines()`。不会自动插入换行符。
          参考： `FILE.writelines()`, `StringIO.StringIO.writelines()`
          参考： [zlib], [zipfile]

[编辑] 模块 -- zipfile : 读写ZIP文件

          [zipfile]模块可以操作各种ZIP文件，包括PKZip,Info-ZIP和WinZip生成的压缩文件。由于ZIP格式可以包含多个文件，所以[zipfile]并不像[gzip]那样采用类文件对象模式。尽管如此，它使用起来还是很方便，可以添加新的文件，创建新的压缩档或处理压缩档里的文件和目录。
          例如，使用[zipfile]模块的常用方式如下。

     >>> for name in 'ABC':
     ...     open(name,'w').write(name*1000)
     ...
     >>> import zipfile
     >>> z = zipfile.ZipFile('new.zip','w',zipfile.ZIP_DEFLATED) # 新压缩档
     >>> z.write('A')                        # 添加文件
     >>> z.write('B','B.newname',zipfile.ZIP_STORED)
     >>> z.write('C','C.newname')
     >>> z.close()                           # 关闭压缩档
     >>> z = zipfile.ZipFile('new.zip')      # 读取压缩档
     >>> z.testzip()                         # 测试，如果正常返回'None'
     >>> z.namelist()                        # 里面有什么？
     ['A', 'B.newname', 'C.newname']
     >>> z.printdir()                        # 细节
     File Name                                   Modified             Size
     A                                    2001-07-18 21:39:36         1000
     B.newname                            2001-07-18 21:39:36         1000
     C.newname                            2001-07-18 21:39:36         1000
     >>> A = z.getinfo('A')                  # 获取ZipInfo对象
     >>> B = z.getinfo('B.newname')          # 获取ZipInfo对象
     >>> A.compress_size
     11
     >>> B.compress_size
     1000
     >>> z.read(A.filename)[:40]             # 读
     'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
     >>> z.read(B.filename)[:40]             # 读
     'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB'
     >>> # For comparison, see what Info-Zip reports on created archive
     >>> import os
     >>> print os.popen('unzip -v new.zip').read()
     Archive:  new.zip
      Length  Method   Size  Ratio   Date    Time   CRC-32     Name
      ------  ------   ----  -----   ----    ----   ------     ----
        1000  Defl:N      11  99%  07-18-01  21:39  51a02e01   A
        1000  Stored    1000   0%  07-18-01  21:39  7d9c564d   B.newname
        1000  Defl:N      11  99%  07-18-01  21:39  66778189   C.newname
      ------          ------  ---                              -------
        3000            1022  66%                              3 files

          模块[zipfile]对[zlib]进行了包装，主要是由后者来做实际的压缩和解压处理。

[编辑] 常数：

          一些字符串常数（[struct]格式）被用来确认ZIP格式。这些常数，一般处理的时候不会被用到。

     #*----- zipfile constants -----#
     zipfile.stringCentralDir = 'PK\x01\x02'
     zipfile.stringEndArchive = 'PK\x05\x06'
     zipfile.stringFileHeader = 'PK\x03\x04'
     zipfile.structCentralDir = '<4s4B4H3l5H2l'
     zipfile.structEndArchive = '<4s4H2lH'
     zipfile.structFileHeader = '<4s2B4H3l2H'

          还有两个象征压缩方法的常数定义。

     #*----- zipfile constants -----#
     zipfile.ZIP_STORED = 0
     zipfile.ZIP_DEFLATED = 8

[编辑] 函数：

          + zipfile.is_zipfile(filename=...)

          检查'filename'对应的文件是否是ZIP压缩档。如果有效则返回1。这个函数并不能保证压缩档完全完整，但可以用于检查压缩档类型。

[编辑] 类：

          + zipfile.PyZipFile(pathname)

          创建`zipfile.ZipFile`对象，包含了`zipfile.ZipFile.writepy()`专用函数，用于压缩'*.py[oc]'。这个类一般用不到，但在使用[distutils]的时候很有用。

          + zipfile.ZipFile(file=... [,mode='r' [,compression=ZIP_STORED]])

          创建新的`zipfile.ZipFile`对象。这个对象用于管理ZIP压缩档。第一个参数'file'指定操作的文件。第二个参数'mode'可以有以下三种字符值：'r'表示只读模式；'w'表示建立新压缩档；'a'表示改写现有的压缩档。参数'compression'指明压缩方法--ZIP_DEFLATED方法需要使用zlib系统库。

          + zipfile.ZipInfo()

          创建新的`zipfile.ZipInfo`对象。这个对象用于处理压缩档内部的文件。一般来说，不需要手动生成`zipfile.ZipInfo`对象，大都是使用`zipfile.ZipFile.infolist()`,`zipfile.ZipFile.getinfo()`和`zipfile.ZipFile.NameToInfo`获取对象。然而，在特殊情况下，像`zipfile.ZipFile.writestr()`会需要用到创建新的`zipfile.ZipInfo`对象。

[编辑] 方法和属性：

          + zipfile.ZipFile.close()

          关闭`zipfile.ZipFile`对象。

          + zipfile.ZipFile.getinfo(name=...)

          返回'name'对应的`zipfile.ZipInfo`对象。如果'name'不是压缩档内部的文件名则会产生'KeyError'错误。

          + zipfile.ZipFile.infolist()

          返回压缩档的所有文件对应的`zipfile.ZipInfo`对象。

          + zipfile.ZipFile.namelist()

          返回压缩档内部的所有文件名（目录会嵌套在列表里）。

          + zipfile.ZipFile.printdir()

          打印内部文件相关信息。类似'unzip'的'-l'操作。

          + zipfile.ZipFile.read(name=...)

          读取内部文件名为'name'的文件内容。

          + zipfile.ZipFile.testzip()

          测试压缩档的完整性。如果有错误则返回第一个出现错误的`zipfile.ZipInfo`对象。如果完整无误则返回None。

          + zipfile.ZipFile.write(filename=... [,arcname=... [,compress_type=...]])

          增加一个'filename'文件。如果第二个参数'arcname'有指明，则使用已存储的文件（否则使用'filename'文件）。第三个参数'compress_type'指明压缩方法。对象必须是'w'或'a'模式。

          + zipfile.ZipFile.writestr(zinfo=..., bytes=...)

          参数'zinfo'指定了写入或增加的文件内部路径信息，参数'bytes'是数据内容。

          + zipfile.ZipFile.NameToInfo

          内部文件名和`zipfile.ZipInfo`对象的对应关系。`zipfile.ZipFile.getinfo()`仅仅是引用这里的某一项。

          + zipfile.ZipFile.compression

          对象使用的压缩方式。

          + zipfile.ZipFile.debug = 0

          设置调试信息的等级。默认为0（没有调试信息），3为详细信息。

          + zipfile.ZipFile.filelist

          内部所有的`zipfile.ZipInfo`对象。

          + zipfile.ZipFile.filename

          `zipfile.ZipFile`对象对应的文件名。不要修改！

          + zipfile.ZipFile.fp

          `zipfile.ZipFile`对象对应的基本文件对象。不要修改！

          + zipfile.ZipFile.mode

          `zipfile.ZipFile`对象的可读写模式。不要修改！

          + zipfile.ZipFile.start_dir

          目录信息的开始位置。不要修改！

          + zipfile.ZipInfo.CRC

          文件的CRC校验值。不要修改！

          + zipfile.ZipInfo.comment

          文件注释。适当修改(主要用于`zipfile.ZipFile.writestr()`).

          + zipfile.ZipInfo.compress_size

          文件的压缩大小。不要修改！

          + zipfile.ZipInfo.compress_type

          文件的压缩方式。适当修改(主要用于`zipfile.ZipFile.writestr()`).

          + zipfile.ZipInfo.create_system

          文件的创建系统。适当修改(主要用于`zipfile.ZipFile.writestr()`).

          + zipfile.ZipInfo.create_version

          文件使用的PKZip版本。适当修改(主要用于`zipfile.ZipFile.writestr()`).

          + zipfile.ZipInfo.date_time

          文件时间戳。适当修改(主要用于`zipfile.ZipFile.writestr()`).

          + zipfile.ZipInfo.external_attr

          文件的解压属性。适当修改(主要用于`zipfile.ZipFile.writestr()`).

          + zipfile.ZipInfo.extract_version

          解压文件需要的PKZip版本。适当修改(主要用于`zipfile.ZipFile.writestr()`).

          + zipfile.ZipInfo.file_offset

          文件的开始位置。不要修改！

          + zipfile.ZipInfo.file_size

          文件的原始大小。不要修改！

          + zipfile.ZipInfo.filename

          文件名。适当修改(主要用于`zipfile.ZipFile.writestr()`).

          + zipfile.ZipInfo.header_offset

          文件头偏移值。不要修改！

          + zipfile.ZipInfo.volume

          文件分卷。不要修改！

[编辑] 异常：

          + zipfile.error

          处理ZIP文件时的错误。

          + zipfile.BadZipFile

          `zipfile.error`的别名。
          参考： [zlib], [gzip]

[编辑] 模块--zlib:压缩和解压的zlib库

          [zlib]是Python标准库里所有压缩模块的底层引擎。此外，[zlib]可以直接压缩和解压数据，而不需要对文件操作。Python的[zlib]模块依赖于平台系统zlib库。
          [zlib]主要有两种基本操作方式，人们可以通过使用`zlib.compress()`来压缩，用`zlib.decompress()`来解压。在更复杂的模式中，还可以创建一个压缩或解压的对象来操作连续的数据块。这种复杂模式的运作类似于`sha.sha.update()`,`md5.md5.update()`,`rotor.encryptmore()`或`binascii.crc32()`，主要用来分次处理大量的数据而不是一次处理。

[编辑] 常数：

          + zlib.ZLIB_VERSION

          系统安装的zlib库版本。

          + zlib.Z_BEST_COMPRESSION = 9

          最高压缩级别。

          + zlib.Z_BEST_SPEED = 1

          最快的压缩级别。

          + zlib.Z_HUFFMAN_ONLY = 2

          中档压缩级别，使用哈夫曼编码，二不是LZ编码。

[编辑] 函数：

          + zlib.adler32(s [,crc])

          返回字符串的Adler32校验码。参数'crc'用于增量校验。Adler32校验比普通CRC32校验快。和[md5]或[sha]不同的是，Adler32校验只能用于检测数据是否损坏，而不用于加密。
          参考： `zlib.crc32()`, [md5], [sha]

          + zlib.compress(s [,level])

          压缩字符串。参数'level'指定压缩的等级，范围从1至9，例如Z_BEST_COMPRESSION和Z_BEST_SPEED，默认值为6。
          参考： `zlib.decompress()`, `zlib.compressobj`

          + zlib.crc32(s [,crc])

          返回字符串的CRC32校验码。参数'crc'用于增量校验。和[md5]或[sha]不同的是，CRC32校验只能用于检测数据是否损坏，而不用于加密。
          相当于`binascii.crc32()`。
          参考： `binascii.crc32()`, `zlib.adler32()`, [md5], [sha]

          + zlib.decompress(s [,winsize [,buffsize]])

          解压字符串。参数'winsize'指定窗口缓冲区的大小，默认是15。参数'buffsize'指定解压缓冲区的大小，默认是16384。一般不需要改变这些默认大小。
          参考： `zlib.compress()`, `zlib.decompressobj`
          对象生成函数：
          [zlib]里并没有直接定义具体的类。`zlib.compressobj()`和`zlib.decompressobj()`是生成对象的函数，而不是类。也就是说，他们返回的对象很像类产生的对象，但没有绑定居体类的成员。对于大多数用户来说，基本上没有差异，二者的使用方法没有什么区别。

          + zlib.compressobj([level])

          创建压缩对象。该压缩对象可以增量逐步压缩字符串块，同时保留先前压缩的内部状态参数。参数'level'指定压缩的等级，范围从1至9，默认值为6。
          参考： `zlib.compress()`, `zlib.decompressobj()`

          + zlib.decompressobj([winsize])

          创建解压对象。该解压对象可以增量逐步解压字符串块，同时保留先前解压的内部状态参数。参数'winsize'指定窗口缓冲区的大小，默认是15。
          参考： `zlib.decompress()`, `zlib.compressobj()`

[编辑] 方法和属性：

          + zlib.compressobj.compress(s)

          添加需要压缩的数据。如果数据足够则返回相应的压缩数据，否则返回空字符串。例如：

     #---------- zlib_objs.py ----------#
     # Demonstrate compression object streams
     import zlib, glob
     decom = zlib.decompressobj()
     com = zlib.compressobj()
     for file in glob.glob('*'):
         s = open(file).read()
         c = com.compress(s)
         print 'COMPRESSED:', len(c), 'bytes out'
         d = decom.decompress(c)
         print 'DECOMPRESS:', len(d), 'bytes out'
         print 'UNUSED DATA:', len(decom.unused_data), 'bytes'
         raw_input('-- %s (%s bytes) --' % (file, `len(s)`))
     f = com.flush()
     m = decom.decompress(f)
     print 'DECOMPRESS:', len(m), 'bytes out'
     print 'UNUSED DATA:', len(decom.unused_data), 'byte'

          参考： `zlib.compressobj.flush()`, `zlib.decompressobj.decompress()`, `zlib.compress()`

          + zlib.compressobj.flush([mode])

          生成完整的压缩数据。参数'mode'默认为Z_FINISH，即该压缩对象不再使用，这时应该'del'它。如果指定Z_SYNC_FLUSH或Z_FULL_FLUSH，压缩对象仍然可以使用，但原先的压缩数据将不再保留。
          参考： `zlib.compress()`, `zlib.compressobj.compress()`

          + zlib.decompressobj.unused_data

          就像上面那个例子显示的那样，`zlib.decompressobj.unused_data`是一个属性而不是方法，其中包含任何还未能处理的解压数据。通常情况下，解压应该是完整的，不会有未处理的数据。然而，如果数据不是一次性全部获得的时候，只作部分解压的时候就会有未处理数据。
          参考： `zlib.decompress()`, `zlib.decompressobj.decompress()`

          + zlib.decompressobj.decompress(s)

          添加解压缩数据。返回解压出的数据，未处理的保留在`zlib.decompressobj.unused_data`。

          + zlib.decompressobj.flush()

          返回全部解压数据。如果解压对象不再使用，您应该`del`它。

[编辑] 异常：

          + zlib.error

          压缩或解压时出现的错误。
          参考： [gzip], [zipfile]

          + 后一页

   取自"http://sunsol.wiki-site.com/index.php/Tpip_224"

查看

     * 文章
     * 讨论
     * 编辑
     * 历史

个人工具

     * 登录／创建账户

导航

     * 首页
     * 最近更改
     * 帮助
     * 资助

搜索

   ____________________ 进入  搜索

工具箱

     * 链入页面
     * 链出更改
     * 上传文件
     * 特殊页面
     * 可打印版
     * 永久链接

   Powered by MediaWiki 
     * 这页的最后修订在 2009年1月15日 (星期四) 13:05。
     * 本页面已经被浏览189次。
     * 隐私政策
     * 关于Sunsol
     * 免责声明

                                     sl

   דומיין בעברית  דומיין  דומין  תוכנה לניהול  קשרי לקוחות  CRM, ניהול קשרי לקוחות  דומין בעברית  פורומים  ספרדית  גיבוי