GNU Info
(python2.1-lib.info)zlib
Compression compatible with `gzip'
==================================
Low-level interface to compression and decompression routines
compatible with `gzip'.
For applications that require data compression, the functions in this
module allow compression and decompression, using the zlib library.
The zlib library has its own home page at <http://www.gzip.org/zlib/>.
Version 1.1.3 is the most recent version as of September 2000; use a
later version if one is available. There are known incompatibilities
between the Python module and earlier versions of the zlib library.
The available exception and functions in this module are:
`error'
Exception raised on compression and decompression errors.
`adler32(string[, value])'
Computes a Adler-32 checksum of STRING. (An Adler-32 checksum is
almost as reliable as a CRC32 but can be computed much more
quickly.) If VALUE is present, it is used as the starting value
of the checksum; otherwise, a fixed default value is used. This
allows computing a running checksum over the concatenation of
several input strings. The algorithm is not cryptographically
strong, and should not be used for authentication or digital
signatures.
`compress(string[, level])'
Compresses the data in STRING, returning a string contained
compressed data. LEVEL is an integer from `1' to `9' controlling
the level of compression; `1' is fastest and produces the least
compression, `9' is slowest and produces the most. The default
value is `6'. Raises the `error' exception if any error occurs.
`compressobj([level])'
Returns a compression object, to be used for compressing data
streams that won't fit into memory at once. LEVEL is an integer
from `1' to `9' controlling the level of compression; `1' is
fastest and produces the least compression, `9' is slowest and
produces the most. The default value is `6'.
`crc32(string[, value])'
Computes a CRC (Cyclic Redundancy Check) checksum of STRING. If
VALUE is present, it is used as the starting value of the
checksum; otherwise, a fixed default value is used. This allows
computing a running checksum over the concatenation of several
input strings. The algorithm is not cryptographically strong, and
should not be used for authentication or digital signatures.
`decompress(string[, wbits[, bufsize]])'
Decompresses the data in STRING, returning a string containing the
uncompressed data. The WBITS parameter controls the size of the
window buffer. If BUFSIZE is given, it is used as the initial
size of the output buffer. Raises the `error' exception if any
error occurs.
The absolute value of WBITS is the base two logarithm of the size
of the history buffer (the "window size") used when compressing
data. Its absolute value should be between 8 and 15 for the most
recent versions of the zlib library, larger values resulting in
better compression at the expense of greater memory usage. The
default value is 15. When WBITS is negative, the standard `gzip'
header is suppressed; this is an undocumented feature of the zlib
library, used for compatibility with `unzip''s compression file
format.
BUFSIZE is the initial size of the buffer used to hold
decompressed data. If more space is required, the buffer size
will be increased as needed, so you don't have to get this value
exactly right; tuning it will only save a few calls to `malloc()'.
The default size is 16384.
`decompressobj([wbits])'
Returns a decompression object, to be used for decompressing data
streams that won't fit into memory at once. The WBITS parameter
controls the size of the window buffer.
Compression objects support the following methods:
`compress(string)'
Compress STRING, returning a string containing compressed data for
at least part of the data in STRING. This data should be
concatenated to the output produced by any preceding calls to the
`compress()' method. Some input may be kept in internal buffers
for later processing.
`flush([mode])'
All pending input is processed, and a string containing the
remaining compressed output is returned. MODE can be selected
from the constants `Z_SYNC_FLUSH', `Z_FULL_FLUSH', or
`Z_FINISH', defaulting to `Z_FINISH'. `Z_SYNC_FLUSH' and
`Z_FULL_FLUSH' allow compressing further strings of data and are
used to allow partial error recovery on decompression, while
`Z_FINISH' finishes the compressed stream and prevents compressing
any more data. After calling `flush()' with MODE set to
`Z_FINISH', the `compress()' method cannot be called again; the
only realistic action is to delete the object.
Decompression objects support the following methods, and a single
attribute:
`unused_data'
A string which contains any unused data from the last string fed to
this decompression object. If the whole string turned out to
contain compressed data, this is `""', the empty string.
The only way to determine where a string of compressed data ends
is by actually decompressing it. This means that when compressed
data is contained part of a larger file, you can only find the end
of it by reading data and feeding it into a decompression object's
`decompress' method until the `unused_data' attribute is no longer
the empty string.
`decompress(string)'
Decompress STRING, returning a string containing the uncompressed
data corresponding to at least part of the data in STRING. This
data should be concatenated to the output produced by any
preceding calls to the `decompress()' method. Some of the input
data may be preserved in internal buffers for later processing.
`flush()'
All pending input is processed, and a string containing the
remaining uncompressed output is returned. After calling
`flush()', the `decompress()' method cannot be called again; the
only realistic action is to delete the object.
See also:
Note: gzip Reading and writing `gzip'-format files.
<http://www.gzip.org/zlib/>
The zlib library home page.
automatically generated by info2www version 1.2.2.9