"binascii" --- Convert between binary and ASCII
***********************************************

======================================================================

The "binascii" module contains a number of methods to convert between
binary and various ASCII-encoded binary representations. Normally, you
will not use these functions directly but use wrapper modules like
"base64" instead. The "binascii" module contains low-level functions
written in C for greater speed that are used by the higher-level
modules.

Note:

  La fonction "a2b_*" accepte des chaînes de caractères contenant
  seulement des caractères ASCII. D’autres fonctions acceptent
  seulement des objets *bytes et similaire* (tel que "bytes",
  "bytearray" et autres objets qui supportent le protocole tampon).

  Modifié dans la version 3.3: Les chaines de caractères *unicode*
  seulement composées de caractères ASCII sont désormais acceptées par
  les fonctions "a2b_*".

Le module "binascii" définit les fonctions suivantes :

binascii.a2b_uu(string)

   Convertit une seule ligne de donnée *uuencoded* en binaire et
   renvoie la donnée binaire. Les lignes contiennent normalement 45
   octets (binaire), sauf pour la dernière ligne. Il se peut que la
   ligne de donnée soit suivie d’un espace blanc.

binascii.b2a_uu(data, *, backtick=False)

   Convertit les données binaires en une ligne de caractères ASCII, la
   valeur renvoyée est la ligne convertie incluant un caractère de
   nouvelle ligne. La longueur de *data* doit être au maximum de 45.
   Si *backtick* est vraie, les zéros sont représentés par "'`'"
   plutôt que par des espaces.

   Modifié dans la version 3.7: Ajout du paramètre *backtick*.

binascii.a2b_base64(string, /, *, strict_mode=False)

   Convertit un bloc de donnée en *base64* en binaire et renvoie la
   donnée binaire. Plus d’une ligne peut être passé à la fois.

   If *strict_mode* is true, only valid base64 data will be converted.
   Invalid base64 data will raise "binascii.Error".

   Valid base64:

   * Conforms to **RFC 3548**.

   * Contains only characters from the base64 alphabet.

   * Contains no excess data after padding (including excess padding,
     newlines, etc.).

   * Does not start with a padding.

   Modifié dans la version 3.11: Added the *strict_mode* parameter.

binascii.b2a_base64(data, *, newline=True)

   Convertit les données binaires en une ligne de caractères ASCII en
   codage base 64. La valeur de renvoyée et la ligne convertie,
   incluant un caractère de nouvelle ligne si *newline* est vraie. La
   sortie de cette fonction se conforme à **RFC 3548**.

   Modifié dans la version 3.6: Ajout du paramètre *newline*.

binascii.a2b_qp(data, header=False)

   Convertit un bloc de données *quoted-printable* en binaire et
   renvoie les données binaires. Plus d’une ligne peut être passée à
   la fois. Si l’argument optionnel *header* est présent et vrai, les
   traits soulignés seront décodés en espaces.

binascii.b2a_qp(data, quotetabs=False, istext=True, header=False)

   Convertit les données binaires en ligne(s) de caractères ASCII en
   codage imprimable entre guillemets. La valeur de retour est lales
   lignes(s) convertie(s). Si l’argument optionnel *quotetabs* est
   présent et vrai, toutes les tabulations et espaces seront encodés.
   Si l’argument optionnel *istext* est présent et faux, les nouvelles
   lignes ne sont pas encodées mais les espaces de fin de ligne le
   seront. Si l’argument optionnel *header* est présent et vrai, les
   espaces vont être encodés comme de traits soulignés selon **RFC
   1522**. Si l’argument optionnel *header* est présent et faux, les
   caractères de nouvelle ligne seront également encodés ; sinon la
   conversion de saut de ligne pourrait corrompre le flux de données
   binaire.

binascii.crc_hqx(data, value)

   Calcule une valeur en CRC 16-bit de *data*, commençant par *value*
   comme CRC initial et renvoie le résultat. Ceci utilise le CRC-CCITT
   polynomial *x*^16 + *x*^12 + *x*^5 + 1, souvent représenté comme
   *0x1021*. Ce CRC est utilisé dans le format *binhex4*.

binascii.crc32(data[, value])

   Compute CRC-32, the unsigned 32-bit checksum of *data*, starting
   with an initial CRC of *value*.  The default initial CRC is zero.
   The algorithm is consistent with the ZIP file checksum.  Since the
   algorithm is designed for use as a checksum algorithm, it is not
   suitable for use as a general hash algorithm.  Use as follows:

      print(binascii.crc32(b"hello world"))
      # Or, in two pieces:
      crc = binascii.crc32(b"hello")
      crc = binascii.crc32(b" world", crc)
      print('crc32 = {:#010x}'.format(crc))

   Modifié dans la version 3.0: The result is always unsigned.

binascii.b2a_hex(data[, sep[, bytes_per_sep=1]])
binascii.hexlify(data[, sep[, bytes_per_sep=1]])

   Renvoie la représentation hexadécimale du binaire *data*. Chaque
   octet de *data* est converti en la représentation 2 chiffres
   correspondante. L’objet octets renvoyé est donc deux fois plus long
   que la longueur de *data*.

   Fonctionnalité similaire est également commodément accessible en
   utilisant la méthode "bytes.hex()".

   Si *sep* est spécifié, il doit s'agir d'une chaîne de caractères ou
   d'un objet *byte*. Il sera inséré dans la sortie tous les
   *bytes_per_sep* octets. Par défaut, l'emplacement du séparateur est
   compté à partir de l'extrémité droite de la sortie. Si vous
   souhaitez compter à partir de la gauche, indiquez une valeur
   *bytes_per_sep* négative.

   >>> import binascii
   >>> binascii.b2a_hex(b'\xb9\x01\xef')
   b'b901ef'
   >>> binascii.hexlify(b'\xb9\x01\xef', '-')
   b'b9-01-ef'
   >>> binascii.b2a_hex(b'\xb9\x01\xef', b'_', 2)
   b'b9_01ef'
   >>> binascii.b2a_hex(b'\xb9\x01\xef', b' ', -2)
   b'b901 ef'

   Modifié dans la version 3.8: ajout des paramètres *sep* et
   *bytes_per_sep*.

binascii.a2b_hex(hexstr)
binascii.unhexlify(hexstr)

   Renvoie la donnée binaire représentée par la chaîne de caractères
   hexadécimale *hexstr*. Cette fonction est l’inverse de "b2a_hex()".
   *hexstr* doit contenir un nombre pair de chiffres hexadécimaux (qui
   peuvent être en majuscule ou minuscule), sinon une exception
   "Error" est levée.

   Une fonctionnalité similaire (n’acceptant que les arguments de
   chaîne de texte, mais plus libérale vis-à-vis des espaces blancs)
   est également accessible en utilisant la méthode de classe
   "bytes.fromhex()".

exception binascii.Error

   Exception levée en cas d'erreurs. Ce sont typiquement des erreurs
   de programmation.

exception binascii.Incomplete

   Exception levée par des données incomplète. Il ne s’agit
   généralement pas d’erreurs de programmation, mais elles peuvent
   être traitées en lisant un peu plus de données et en réessayant.

Voir aussi:

  Module "base64"
     Support de l’encodage *base64-style* conforme RFC en base 16, 32,
     64 et 85.

  Module "quopri"
     Support de l’encodage *quote-printable* utilisé par les messages
     *email* MIME.
