# 12.4. `zipfile` — Travailler avec des archives ZIP

Nouveau dans la version 1.6.

Code source : Lib/zipfile.py

Le format de fichier ZIP est une archive et un standard de compression couramment utilisés. Ce module fournit des outils pour créer, écrire, ajouter des données à et lister un fichier ZIP. L’utilisation avancée de ce module requiert une certaine compréhension du format, comme défini dans PKZIP Application Note.

This module does not currently handle multi-disk ZIP files. It can handle ZIP files that use the ZIP64 extensions (that is ZIP files that are more than 4 GByte in size). It supports decryption of encrypted files in ZIP archives, but it currently cannot create an encrypted file. Decryption is extremely slow as it is implemented in native Python rather than C.

Le module définit les éléments suivants :

exception `zipfile.``BadZipfile`

  The error raised for bad ZIP files (old name: `zipfile.error`).

exception `zipfile.``LargeZipFile`

  Erreur levée quand un fichier ZIP nécessite la fonctionnalité ZIP64 mais qu’elle n’a pas été activée.

class `zipfile.``ZipFile`

  Classe pour lire et écrire des fichiers ZIP. Voir la section Objets ZipFile pour les détails du constructeur.

class `zipfile.``PyZipFile`

  Classe pour créer des archives ZIP contenant des bibliothèques Python.

class `zipfile.``ZipInfo`([filename[, date_time]])

  Classe utilisée pour représenter les informations d’un membre d’une archive. Les instances de cette classe sont retournées par les méthodes `getinfo()` et `infolist()` des objets `ZipFile`. La plupart des utilisateurs du module `zipfile` n’ont pas besoin de créer ces instances mais d’utiliser celles créées par ce module. filename doit être le nom complet du membre de l’archive et date_time doit être un tuple contenant six champs qui décrit la date de dernière modification du fichier ; les champs sont décrits dans la section Objets ZipInfo.

`zipfile.``is_zipfile`(filename)

  Retourne `True` si filename est un fichier ZIP valide basé sur son nombre magique, sinon retourne `False`. filename peut aussi être un fichier ou un objet fichier-compatible.

  Modifié dans la version 2.7: Gestion des objets fichier et fichier-compatibles.

`zipfile.``ZIP_STORED`

  Constante numérique pour un membre d’une archive décompressée.

`zipfile.``ZIP_DEFLATED`

  The numeric constant for the usual ZIP compression method. This requires the `zlib` module. No other compression methods are currently supported.

Voir aussi

PKZIP Application Note

  Documentation sur le format de fichier ZIP par Phil Katz, créateur du format et des algorithmes utilisés.

Info-ZIP Home Page

  Informations sur les programmes et les bibliothèques de développement d’archivage ZIP du projet Info-ZIP.

## 12.4.1. Objets ZipFile

class `zipfile.``ZipFile`(file[, mode[, compression[, allowZip64]]])

  Open a ZIP file, where file can be either a path to a file (a string) or a file-like object. The mode parameter should be `'r'` to read an existing file, `'w'` to truncate and write a new file, or `'a'` to append to an existing file. If mode is `'a'` and file refers to an existing ZIP file, then additional files are added to it. If file does not refer to a ZIP file, then a new ZIP archive is appended to the file. This is meant for adding a ZIP archive to another file (such as `python.exe`).

  Modifié dans la version 2.6: If mode is `a` and the file does not exist at all, it is created.

  compression is the ZIP compression method to use when writing the archive, and should be `ZIP_STORED` or `ZIP_DEFLATED`; unrecognized values will cause `RuntimeError` to be raised. If `ZIP_DEFLATED` is specified but the `zlib` module is not available, `RuntimeError` is also raised. The default is `ZIP_STORED`. If allowZip64 is `True` zipfile will create ZIP files that use the ZIP64 extensions when the zipfile is larger than 2 GB. If it is false (the default) `zipfile` will raise an exception when the ZIP file would require ZIP64 extensions. ZIP64 extensions are disabled by default because the default zip and unzip commands on Unix (the InfoZIP utilities) don’t support these extensions.

  Modifié dans la version 2.7.1: If the file is created with mode `'a'` or `'w'` and then `closed` without adding any files to the archive, the appropriate ZIP structures for an empty archive will be written to the file.

  ZipFile is also a context manager and therefore supports the `with` statement. In the example, myzip is closed after the `with` statement’s suite is finished—even if an exception occurs:

      with ZipFile('spam.zip', 'w') as myzip:
          myzip.write('eggs.txt')

  Nouveau dans la version 2.7: Ajout de la possibilité d’utiliser `ZipFile` comme un gestionnaire de contexte.

`ZipFile.``close`()

  Ferme l’archive. Vous devez appeler `close()` avant de terminer votre programme ou des informations essentielles n’y seront pas enregistrées.

`ZipFile.``getinfo`(name)

  Retourne un objet `ZipInfo` avec les informations du membre name de l’archive. Appeler `getinfo()` pour un nom non contenu dans l’archive lève une exception `KeyError`.

`ZipFile.``infolist`()

  Retourne une liste contenant un objet `ZipInfo` pour chaque membre de l’archive. Les objets ont le même ordre que leurs entrées dans le fichier ZIP présent sur disque s’il s’agissait d’une archive préexistante.

`ZipFile.``namelist`()

  Retourne une liste des membres de l’archive indexés par leur nom.

`ZipFile.``open`(name[, mode[, pwd]])

  Extract a member from the archive as a file-like object (ZipExtFile). name is the name of the file in the archive, or a `ZipInfo` object. The mode parameter, if included, must be one of the following: `'r'` (the default), `'U'`, or `'rU'`. Choosing `'U'` or `'rU'` will enable universal newline support in the read-only object. pwd is the password used for encrypted files. Calling `open()` on a closed ZipFile will raise a `RuntimeError`.

  Note

  The file-like object is read-only and provides the following methods: `read()`, `readline()`, `readlines()`, `__iter__()`, `next()`.

  Note

  If the ZipFile was created by passing in a file-like object as the first argument to the constructor, then the object returned by `open()` shares the ZipFile’s file pointer. Under these circumstances, the object returned by `open()` should not be used after any additional operations are performed on the ZipFile object. If the ZipFile was created by passing in a string (the filename) as the first argument to the constructor, then `open()` will create a new file object that will be held by the ZipExtFile, allowing it to operate independently of the ZipFile.

  Note

  Les méthodes `open()`, `read()` et `extract()` peuvent prendre un nom de fichier ou un objet `ZipInfo`. Cela est appréciable lorsqu’on essaie de lire un fichier ZIP qui contient des membres avec des noms en double.

  Nouveau dans la version 2.6.

`ZipFile.``extract`(member[, path[, pwd]])

  Extract a member from the archive to the current working directory; member must be its full name or a `ZipInfo` object). Its file information is extracted as accurately as possible. path specifies a different directory to extract to. member can be a filename or a `ZipInfo` object. pwd is the password used for encrypted files.

  Retourne le chemin normalisé créé (un dossier ou un nouveau fichier).

  Nouveau dans la version 2.6.

  Note

  Si le nom de fichier d’un membre est un chemin absolu, le disque/partage UNC et les (anti)slashes de départ seront supprimés, par exemple ///foo/bar` devient `foo/bar` sous Unix et `C:\foo\bar` devient `foo\bar` sous Windows. Et tous les composants `".."` dans le nom de fichier d’un membre seront supprimés, par exemple `../../foo../../ba..r` devient `foo../ba..r`. Sous Windows les caractères illégaux (`:`, `<`, `>`, `|`, `"`, `?` et `*`) sont remplacés par un underscore (`_`).

`ZipFile.``extractall`([path[, members[, pwd]]])

  Extrait tous les membres de l’archive dans le répertoire courant. path spécifie un dossier de destination différent. members est optionnel et doit être un sous-ensemble de la liste retournée par `namelist()`. pwd est le mot de passe utilisé pour les fichiers chiffrés.

  Avertissement

  Never extract archives from untrusted sources without prior inspection. It is possible that files are created outside of path, e.g. members that have absolute filenames starting with `"/"` or filenames with two dots `".."`.

  Modifié dans la version 2.7.4: The zipfile module attempts to prevent that. See `extract()` note.

  Nouveau dans la version 2.6.

`ZipFile.``printdir`()

  Affiche la liste des contenus de l’archive sur `sys.stdout`.

`ZipFile.``setpassword`(pwd)

  Définit pwd comme mot de passe par défait pour extraire des fichiers chiffrés.

  Nouveau dans la version 2.6.

`ZipFile.``read`(name[, pwd])

  Return the bytes of the file name in the archive. name is the name of the file in the archive, or a `ZipInfo` object. The archive must be open for read or append. pwd is the password used for encrypted files and, if specified, it will override the default password set with `setpassword()`. Calling `read()` on a closed ZipFile will raise a `RuntimeError`.

  Modifié dans la version 2.6: pwd was added, and name can now be a `ZipInfo` object.

`ZipFile.``testzip`()

  Read all the files in the archive and check their CRC’s and file headers. Return the name of the first bad file, or else return `None`. Calling `testzip()` on a closed ZipFile will raise a `RuntimeError`.

`ZipFile.``write`(filename[, arcname[, compress_type]])

  Write the file named filename to the archive, giving it the archive name arcname (by default, this will be the same as filename, but without a drive letter and with leading path separators removed). If given, compress_type overrides the value given for the compression parameter to the constructor for the new entry. The archive must be open with mode `'w'` or `'a'` – calling `write()` on a ZipFile created with mode `'r'` will raise a `RuntimeError`. Calling `write()` on a closed ZipFile will raise a `RuntimeError`.

  Note

  Il n’y a pas d’encodage de nom de fichier officiel pour les fichiers ZIP. Si vous avez des noms de fichier unicode, vous devez les convertir en chaînes d’octets dans l’encodage désiré avant de les passer à `write()`. WinZip interprète tous les noms de fichier comme encodés en CP437, aussi connu sous le nom de DOS Latin.

  Note

  Les noms d’archive doivent être relatifs à la racine de l’archive, c’est-à-dire qu’ils ne doivent pas commencer par un séparateur de chemin.

  Note

  Si `arcname` (ou `filename` si `arcname` n’est pas donné) contient un octet nul, le nom du fichier dans l’archive sera tronqué à l’octet nul.

`ZipFile.``writestr`(zinfo_or_arcname, bytes[, compress_type])

  Write the string bytes to the archive; zinfo_or_arcname is either the file name it will be given in the archive, or a `ZipInfo` instance. If it’s an instance, at least the filename, date, and time must be given. If it’s a name, the date and time is set to the current date and time. The archive must be opened with mode `'w'` or `'a'` – calling `writestr()` on a ZipFile created with mode `'r'` will raise a `RuntimeError`. Calling `writestr()` on a closed ZipFile will raise a `RuntimeError`.

  If given, compress_type overrides the value given for the compression parameter to the constructor for the new entry, or in the zinfo_or_arcname (if that is a `ZipInfo` instance).

  Note

  Lorsque l’on passe une instance de `ZipInfo` dans le paramètre zinfo_or_arcname, la méthode de compression utilisée sera celle spécifiée dans le membre compress_type de l’instance `ZipInfo` donnée. Par défaut, le constructeur de la classe `ZipInfo` définit ce membre à `ZIP_STORED`.

  Modifié dans la version 2.7: L’argument compress_type.

Les attributs suivants sont aussi disponibles :

`ZipFile.``debug`

  Le niveau d’affichage de debug à utiliser. Peut être défini de `0` (par défaut, pas d’affichage) à `3` (affichage le plus bavard). Les informations de débogage sont affichées sur `sys.stdout`.

`ZipFile.``comment`

  The comment text associated with the ZIP file. If assigning a comment to a `ZipFile` instance created with mode “a” or “w”, this should be a string no longer than 65535 bytes. Comments longer than this will be truncated in the written archive when `close()` is called.

## 12.4.2. Objets PyZipFile

The `PyZipFile` constructor takes the same parameters as the `ZipFile` constructor. Instances have one method in addition to those of `ZipFile` objects.

`PyZipFile.``writepy`(pathname[, basename])

  Search for files `*.py` and add the corresponding file to the archive. The corresponding file is a `*.pyo` file if available, else a `*.pyc` file, compiling if necessary. If the pathname is a file, the filename must end with `.py`, and just the (corresponding `*.py[co]`) file is added at the top level (no path information). If the pathname is a file that does not end with `.py`, a `RuntimeError` will be raised. If it is a directory, and the directory is not a package directory, then all the files `*.py[co]` are added at the top level. If the directory is a package directory, then all `*.py[co]` are added under the package name as a file path, and if any subdirectories are package directories, all of these are added recursively. basename is intended for internal use only. The `writepy()` method makes archives with file names like this:

      string.pyc                                # Top level name
      test/__init__.pyc                         # Package directory
      test/test_support.pyc                          # Module test.test_support
      test/bogus/__init__.pyc                   # Subpackage directory
      test/bogus/myfile.pyc                     # Submodule test.bogus.myfile

## 12.4.3. Objets ZipInfo

Des instances de la classe `ZipInfo` sont retournées par les méthodes `getinfo()` et `infolist()` des objets `ZipFile`. Chaque objet stocke des informations sur un seul membre de l’archive ZIP.

Instances have the following attributes:

`ZipInfo.``filename`

  Nom du fichier dans l’archive.

`ZipInfo.``date_time`

  Date et heure de dernière modification pour le membre de l’archive. Tuple de six valeurs :

  Index | Valeur
  --- | ---
  `0` | Année (>= 1980)
  `1` | Mois (indexé à partir de 1)
  `2` | Jour du mois (indexé à partir de 1)
  `3` | Heures (indexées à partir de 0)
  `4` | Minutes (indexées à partir de 0)
  `5` | Secondes (indexées à partir de 0)

  Note

  Le format de fichier ZIP ne gère pas les horodatages avant 1980.

`ZipInfo.``compress_type`

  Type de compression du membre d’archive.

`ZipInfo.``comment`

  Comment for the individual archive member.

`ZipInfo.``extra`

  Expansion field data. The PKZIP Application Note contains some comments on the internal structure of the data contained in this string.

`ZipInfo.``create_system`

  Système ayant créé l’archive ZIP.

`ZipInfo.``create_version`

  Version de PKZIP ayant créé l’archive ZIP.

`ZipInfo.``extract_version`

  Version de PKZIP nécessaire à l’extraction de l’archive ZIP.

`ZipInfo.``reserved`

  Doit être à zéro.

`ZipInfo.``flag_bits`

  Bits d’options ZIP.

`ZipInfo.``volume`

  Numéro de volume de l’entête du fichier.

`ZipInfo.``internal_attr`

  Attributs internes.

`ZipInfo.``external_attr`

  Attributs de fichier externes.

`ZipInfo.``header_offset`

  Longueur de l’entête du fichier en octets.

`ZipInfo.``CRC`

  CRC-32 du fichier décompressé.

`ZipInfo.``compress_size`

  Taille des données décompressées.

`ZipInfo.``file_size`

  Taille du fichier décompressé.

## 12.4.4. Command-Line Interface

The `zipfile` module provides a simple command-line interface to interact with ZIP archives.

If you want to create a new ZIP archive, specify its name after the `-c` option and then list the filename(s) that should be included:

    $ python -m zipfile -c monty.zip spam.txt eggs.txt

Passing a directory is also acceptable:

    $ python -m zipfile -c monty.zip life-of-brian_1979/

If you want to extract a ZIP archive into the specified directory, use the `-e` option:

    $ python -m zipfile -e monty.zip target-dir/

For a list of the files in a ZIP archive, use the `-l` option:

    $ python -m zipfile -l monty.zip

### 12.4.4.1. Command-line options

`-l``<zipfile>`

  List files in a zipfile.

`-c``<zipfile> <source1> ... <sourceN>`

  Create zipfile from source files.

`-e``<zipfile> <output_dir>`

  Extract zipfile into target directory.

`-t``<zipfile>`

  Test whether the zipfile is valid or not.