"array" --- Efficient arrays of numeric values
**********************************************

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

This module defines an object type which can compactly represent an
array of basic values: characters, integers, floating-point numbers.
Arrays are mutable *sequence* types and behave very much like lists,
except that the type of objects stored in them is constrained.  The
type is specified at object creation time by using a *type code*,
which is a single character.  The following type codes are defined:

+-------------+----------------------+---------------------+-------------------------+---------+
| Code d'ind  | Type C               | Type Python         | Taille minimum en       | Notes   |
| ication du  |                      |                     | octets                  |         |
| type        |                      |                     |                         |         |
|=============|======================|=====================|=========================|=========|
| "'b'"       | "signed char"        | *int*               | 1                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'B'"       | "unsigned char"      | *int*               | 1                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'u'"       | wchar_t              | Caractère Unicode   | 2                       | (1)     |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'w'"       | Py_UCS4              | Caractère Unicode   | 4                       | (2)     |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'h'"       | "signed short"       | *int*               | 2                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'H'"       | "unsigned short"     | *int*               | 2                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'i'"       | "signed int"         | *int*               | 2                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'I'"       | "unsigned int"       | *int*               | 2                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'l'"       | "signed long"        | *int*               | 4                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'L'"       | "unsigned long"      | *int*               | 4                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'q'"       | "signed long long"   | *int*               | 8                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'Q'"       | "unsigned long long" | *int*               | 8                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'f'"       | *float*              | *float*             | 4                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+
| "'d'"       | double               | *float*             | 8                       |         |
+-------------+----------------------+---------------------+-------------------------+---------+

Notes :

1. It can be 16 bits or 32 bits depending on the platform.

   Modifié dans la version 3.9: "array('u')" now uses "wchar_t" as C
   type instead of deprecated "Py_UNICODE". This change doesn't affect
   its behavior because "Py_UNICODE" is alias of "wchar_t" since
   Python 3.3.

   Deprecated since version 3.3, will be removed in version 3.16:
   Please migrate to "'w'" typecode.

2. Ajouté dans la version 3.13.

The actual representation of values is determined by the machine
architecture (strictly speaking, by the C implementation).  The actual
size can be accessed through the "array.itemsize" attribute.

The module defines the following item:

array.typecodes

   Une chaîne avec tous les codes de types disponibles.

Le module définit le type suivant :

class array.array(typecode[, initializer])

   A new array whose items are restricted by *typecode*, and
   initialized from the optional *initializer* value, which must be a
   "bytes" or "bytearray" object, a Unicode string, or iterable over
   elements of the appropriate type.

   If given a "bytes" or "bytearray" object, the initializer is passed
   to the new array's "frombytes()" method; if given a Unicode string,
   the initializer is passed to the "fromunicode()" method; otherwise,
   the initializer's iterator is passed to the "extend()" method to
   add initial items to the array.

   Array objects support the ordinary mutable *sequence* operations of
   indexing, slicing, concatenation, and multiplication.  When using
   slice assignment, the assigned value must be an array object with
   the same type code; in all other cases, "TypeError" is raised.
   Array objects also implement the buffer interface, and may be used
   wherever *bytes-like objects* are supported.

   Lève un événement d'audit "array.__new__" avec les arguments
   "typecode", "initializer".

   typecode

      Le code (de type Python caractère) utilisé pour spécifier le
      type des éléments du tableau.

   itemsize

      La longueur en octets d'un élément du tableau dans la
      représentation interne.

   append(x)

      Ajoute un nouvel élément avec la valeur *x* à la fin du tableau.

   buffer_info()

      Return a tuple "(address, length)" giving the current memory
      address and the length in elements of the buffer used to hold
      array's contents.  The size of the memory buffer in bytes can be
      computed as "array.buffer_info()[1] * array.itemsize".  This is
      occasionally useful when working with low-level (and inherently
      unsafe) I/O interfaces that require memory addresses, such as
      certain "ioctl()" operations.  The returned numbers are valid as
      long as the array exists and no length-changing operations are
      applied to it.

      Note:

        Lors de l'utilisation d'objets tableaux provenant de codes
        écrits en C ou C++ (le seul moyen d'utiliser efficacement ces
        informations), il est plus logique d'utiliser l'interface
        tampon supportée par les objets tableaux. Cette méthode est
        maintenue pour des raisons de rétrocompatibilité et devrait
        être évitée dans un nouveau code. L'interface tampon est
        documentée dans Protocole tampon.

   byteswap()

      Boutisme de tous les éléments du tableau. Ceci n'est pris en
      charge que pour les valeurs de 1, 2, 4 ou 8 octets ; pour les
      autres types de valeur, "RuntimeError" est levée. Il est utile
      lors de la lecture de données à partir d'un fichier écrit sur
      une machine avec un ordre d'octets différent.

   count(x)

      Renvoi le nombre d'occurrences de *x* dans le tableau.

   extend(iterable)

      Ajoute les éléments de *iterable* à la fin du tableau. Si
      *iterable* est un autre tableau, il doit le même code
      d'indication du type ; dans le cas contraire, "TypeError" sera
      levée. Si *iterable* n'est pas un tableau, il doit être itérable
      et ces éléments doivent être du bon type pour être ajoutés dans
      le tableau.

   frombytes(buffer)

      Appends items from the *bytes-like object*, interpreting its
      content as an array of machine values (as if it had been read
      from a file using the "fromfile()" method).

      Ajouté dans la version 3.2: "fromstring()" is renamed to
      "frombytes()" for clarity.

   fromfile(f, n)

      Read *n* items (as machine values) from the *file object* *f*
      and append them to the end of the array.  If less than *n* items
      are available, "EOFError" is raised, but the items that were
      available are still inserted into the array.

   fromlist(list)

      Ajoute les éléments de la liste. C'est l'équivalent de "for x in
      list: a.append(x)" sauf que s'il y a une erreur de type, le
      tableau est inchangé.

   fromunicode(s)

      Extends this array with data from the given Unicode string. The
      array must have type code "'u'" or "'w'"; otherwise a
      "ValueError" is raised. Use
      "array.frombytes(unicodestring.encode(enc))" to append Unicode
      data to an array of some other type.

   index(x[, start[, stop]])

      Return the smallest *i* such that *i* is the index of the first
      occurrence of *x* in the array.  The optional arguments *start*
      and *stop* can be specified to search for *x* within a
      subsection of the array.  Raise "ValueError" if *x* is not
      found.

      Modifié dans la version 3.10: Added optional *start* and *stop*
      parameters.

   insert(i, x)

      Ajoute un nouvel élément avec la valeur *x* dans le tableau
      avant la position *i*. Les valeurs négatives sont traitées
      relativement à la fin du tableau.

   pop([i])

      Supprime l'élément du tableau avec l'index *i* et le renvoie.
      L'argument optionnel par défaut est à "-1", de sorte que par
      défaut le dernier élément est supprimé et renvoyé.

   remove(x)

      Supprime la première occurrence de *x* du tableau.

   clear()

      Remove all elements from the array.

      Ajouté dans la version 3.13.

   reverse()

      Inverse l'ordre des éléments du tableau.

   tobytes()

      Convertit le tableau en un tableau de valeurs machine et renvoie
      la représentation en octets (la même séquence d'octets qui
      serait écrite par la méthode "tofile()").

      Ajouté dans la version 3.2: "tostring()" is renamed to
      "tobytes()" for clarity.

   tofile(f)

      Écrit tous les éléments (en tant que valeurs machine) du *file
      object* *f*.

   tolist()

      Convertit le tableau en une liste ordinaire avec les mêmes
      éléments.

   tounicode()

      Convert the array to a Unicode string.  The array must have a
      type "'u'" or "'w'"; otherwise a "ValueError" is raised. Use
      "array.tobytes().decode(enc)" to obtain a Unicode string from an
      array of some other type.

The string representation of array objects has the form
"array(typecode, initializer)". The *initializer* is omitted if the
array is empty, otherwise it is a Unicode string if the *typecode* is
"'u'" or "'w'", otherwise it is a list of numbers. The string
representation is guaranteed to be able to be converted back to an
array with the same type and value using "eval()", so long as the
"array" class has been imported using "from array import array".
Variables "inf" and "nan" must also be defined if it contains
corresponding floating-point values. Examples:

   array('l')
   array('w', 'hello \u2641')
   array('l', [1, 2, 3, 4, 5])
   array('d', [1.0, 2.0, 3.14, -inf, nan])

Voir aussi:

  Module "struct"
     Empaquetage et dépaquetage de données binaires hétérogènes.

  NumPy
     The NumPy package defines another array type.
