bz2 — Prise en charge de la compression bzip2

Code Source : Lib/bz2.py

Ce module fournit une interface complète pour compresser et décompresser les données en utilisant l'algorithme de compression bzip2.

Le module bz2 contient :

(Dé)compression de fichiers

bz2.open(filename, mode='rb', compresslevel=9, encoding=None, errors=None, newline=None)

Ouvre un fichier compressé par bzip2 en mode binaire ou texte, le renvoyant en file object.

Tout comme avec le constructeur pour la classe BZ2File, l'argument filename peut être un nom de fichier réel (un objet str ou bytes), ou un objet fichier existant à lire ou à écrire.

L'argument mode peut valoir 'r', 'rb', 'w', 'wb', 'x', 'xb', 'a' ou 'ab' pour le mode binaire, ou 'rt', 'wt', 'xt' ou 'at' pour le mode texte. Il vaut par défaut 'rb'.

L'argument compresslevel est un entier de 1 à 9, comme pour le constructeur BZ2File.

Pour le mode binaire, cette fonction est équivalente au constructeur BZ2File : BZ2File(filename, mode, compresslevel=compresslevel). Dans ce cas, les arguments encoding, errors et newline arguments ne doivent pas être fournis.

Pour le mode texte, un objet BZ2File est créé et encapsulé dans une instance io.TextIOWrapper avec l'encodage spécifié, le comportement de gestion des erreurs et les fins de ligne.

Nouveau dans la version 3.3.

Modifié dans la version 3.4: Le mode 'x' (création exclusive) est ajouté.

Modifié dans la version 3.6: Accepte un path-like object.

class bz2.BZ2File(filename, mode='r', *, compresslevel=9)

Ouvre un fichier bzip2 en mode binaire.

Si filename est un objet str ou bytes, ouvre le nom de fichier directement. Autrement, filename doit être un file object, qui est utilisé pour lire ou écrire les données compressées.

L'argument mode peut être soit 'r' pour lire (par défaut), 'w' pour écraser, 'x' pour créer exclusivement, ou 'a' pour ajouter. Ils peuvent également être écrits respectivement comme 'rb', 'wb', 'xb' et 'ab'.

Si filename est un objet fichier (plutôt que le nom de fichier réel), le mode 'w' ne tronque pas le fichier, mais équivaut à 'a'.

Si mode est 'w' ou 'a', compresslevel peut être un entier entre 1 et 9 spécifiant le niveau de compression : 1 utilise la compression la moins forte, et 9 (par défaut) la compression la plus forte.

Si mode est 'r', le fichier d'entrée peut être la concaténation de plusieurs flux compressés.

BZ2File fournit tous les membres spécifiés par la classe io.BufferedIOBase, excepté les méthodes detach() et truncate(). L'itération et l'instruction with sont prises en charge.

BZ2File fournit aussi la méthode suivante :

peek([n])

Renvoie des données en mémoire tampon sans avancer la position du fichier. Au moins un octet de donnée (sauf l'EOF) est renvoyé. Le nombre exact d'octets renvoyés n'est pas spécifié.

Note

Bien que l'appel à la méthode peek() ne change pas la position du fichier de la classe BZ2File, il peut changer la position de l'objet fichier sous-jacent (e.g. si la classe BZ2File a été construite en passant un objet fichier à filename).

Nouveau dans la version 3.3.

Modifié dans la version 3.1: La prise en charge de l'instruction with a été ajoutée.

Modifié dans la version 3.3: Les méthodes fileno(), readable(), seekable(), writable(), read1() et readinto() ont été ajoutées.

Modifié dans la version 3.3: La gestion de filename comme file object au lieu d'un nom de fichier réel a été ajoutée.

Modifié dans la version 3.3: Le mode 'a' (ajout) a été ajouté, avec la prise en charge de la lecture des fichiers multiflux.

Modifié dans la version 3.4: Le mode 'x' (création exclusive) est ajouté.

Modifié dans la version 3.5: La méthode read() accepte maintenant un argument None.

Modifié dans la version 3.6: Accepte un path-like object.

Modifié dans la version 3.9: Le paramètre buffering a été supprimé. Il était ignoré et obsolète depuis Python 3.0. Passez un objet fichier déjà ouvert si vous voulez contrôler la façon dont le fichier est ouvert.

Le paramètre compresslevel est devenu un paramètre exclusivement nommé.

Modifié dans la version 3.10: Cette classe n'est plus protégée d'un accès concurrent malheureux par plusieurs lecteurs ou compresseurs. C'était déjà le cas depuis toujours des classes analogues dans les modules gzip et lzma.

(Dé)compression incrémentielle

class bz2.BZ2Compressor(compresslevel=9)

Crée un nouvel objet compresseur. Cet objet peut être utilisé pour compresser les données de manière incrémentielle. Pour une compression en une seule fois, utilisez à la place la fonction compress().

compresslevel, s'il est fourni, doit être un entier entre 1 et 9. Sa valeur par défaut est 9.

compress(data)

Fournit la donnée à l'objet compresseur. Renvoie un bloc de données compressées si possible, ou autrement une chaîne d'octet vide.

Quand vous avez fini de fournir des données au compresseur, appelez la méthode flush() pour finir le processus de compression.

flush()

Finit le processus de compression. Renvoie la donnée compressée restante dans les tampons internes.

L'objet compresseur ne peut pas être utilisé après que cette méthode a été appelée.

class bz2.BZ2Decompressor

Crée un nouvel objet décompresseur. Cet objet peut être utilisé pour décompresser les données de manière incrémentielle. Pour une compression en une seule fois, utilisez à la place la fonction decompress().

Note

Cette classe ne gère pas de manière transparente les entrées contenant plusieurs flux compressés, à la différence de decompress() et BZ2File. Si vous avez besoin de décompresser une entrée multiflux avec la classe BZ2Decompressor, vous devez utiliser un nouveau décompresseur pour chaque flux.

decompress(data, max_length=- 1)

Décompresse data (un bytes-like object), renvoyant une donnée non compressée en tant que chaîne d'octets. Certaines de ces data peuvent être mises en interne en tampon, pour un usage lors d'appels ultérieurs par la méthode decompress(). La donnée renvoyée doit être concaténée avec la sortie des appels précédents à la méthode decompress().

Si max_length est positif, renvoie au plus max_length octets de données compressées. Si la limite est atteinte et que d'autres sorties peuvent être produites, l'attribut needs_input est positionné sur False. Dans ce cas, lors de l'appel suivant à la méthode decompress(), vous pouvez fournir b'' dans data afin d'obtenir la suite de la sortie.

Si toutes les données entrées ont été décompressées et renvoyées (soit parce qu'il y avait moins de max_length octets, ou parce que max_length était négatif), l'attribut needs_input sera configuré sur True.

Attempting to decompress data after the end of stream is reached raises an EOFError. Any data found after the end of the stream is ignored and saved in the unused_data attribute.

Modifié dans la version 3.5: Ajout du paramètre max_length.

eof

True si le marqueur de fin de flux a été atteint.

Nouveau dans la version 3.3.

unused_data

Donnée trouvée après la fin du flux compressé.

Si l'attribut est accédé avant que la fin du flux ait été atteint, sa valeur sera b''.

needs_input

False si la méthode decompress() peut fournir plus de données décompressées avant l'acquisition d'une nouvelle entrée non compressée.

Nouveau dans la version 3.5.

(Dé)compression en une fois

bz2.compress(data, compresslevel=9)

Compresse data, un bytes-like object.

compresslevel, s'il est fourni, doit être un entier entre 1 et 9. Sa valeur par défaut est 9.

Pour la compression incrémentielle, utilisez à la place la classe BZ2Compressor.

bz2.decompress(data)

Décompresse data, un bytes-like object.

Si data est la concaténation de multiples flux compressés, décompresse tous les flux.

Pour une décompression incrémentielle, utilisez à la place la classe BZ2Decompressor.

Modifié dans la version 3.3: Prise en charge des entrées multiflux.

Exemples d'utilisation

Ci-dessous, nous présentons quelques exemples typiques de l'utilisation du module bz2.

Utilise les fonctions compress() et decompress() pour démontrer une compression aller-retour :

>>> import bz2
>>> data = b"""\
... Donec rhoncus quis sapien sit amet molestie. Fusce scelerisque vel augue
... nec ullamcorper. Nam rutrum pretium placerat. Aliquam vel tristique lorem,
... sit amet cursus ante. In interdum laoreet mi, sit amet ultrices purus
... pulvinar a. Nam gravida euismod magna, non varius justo tincidunt feugiat.
... Aliquam pharetra lacus non risus vehicula rutrum. Maecenas aliquam leo
... felis. Pellentesque semper nunc sit amet nibh ullamcorper, ac elementum
... dolor luctus. Curabitur lacinia mi ornare consectetur vestibulum."""
>>> c = bz2.compress(data)
>>> len(data) / len(c)  # Data compression ratio
1.513595166163142
>>> d = bz2.decompress(c)
>>> data == d  # Check equality to original object after round-trip
True

Utilise la classe BZ2Compressor pour une compression incrémentielle :

>>> import bz2
>>> def gen_data(chunks=10, chunksize=1000):
...     """Yield incremental blocks of chunksize bytes."""
...     for _ in range(chunks):
...         yield b"z" * chunksize
...
>>> comp = bz2.BZ2Compressor()
>>> out = b""
>>> for chunk in gen_data():
...     # Provide data to the compressor object
...     out = out + comp.compress(chunk)
...
>>> # Finish the compression process.  Call this once you have
>>> # finished providing data to the compressor.
>>> out = out + comp.flush()

The example above uses a very "nonrandom" stream of data (a stream of b"z" chunks). Random data tends to compress poorly, while ordered, repetitive data usually yields a high compression ratio.

Écriture et lecture en mode binaire d'un fichier compressé avec bzip2 :

>>> import bz2
>>> data = b"""\
... Donec rhoncus quis sapien sit amet molestie. Fusce scelerisque vel augue
... nec ullamcorper. Nam rutrum pretium placerat. Aliquam vel tristique lorem,
... sit amet cursus ante. In interdum laoreet mi, sit amet ultrices purus
... pulvinar a. Nam gravida euismod magna, non varius justo tincidunt feugiat.
... Aliquam pharetra lacus non risus vehicula rutrum. Maecenas aliquam leo
... felis. Pellentesque semper nunc sit amet nibh ullamcorper, ac elementum
... dolor luctus. Curabitur lacinia mi ornare consectetur vestibulum."""
>>> with bz2.open("myfile.bz2", "wb") as f:
...     # Write compressed data to file
...     unused = f.write(data)
>>> with bz2.open("myfile.bz2", "rb") as f:
...     # Decompress data from file
...     content = f.read()
>>> content == data  # Check equality to original object after round-trip
True