# `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 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'indication du type | Type C | Type Python | Taille minimum en octets | Notes
--- | --- | --- | --- | ---
`'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.

  Les objets de tableau supportent les opérations classiques de séquence : indiçage, découpage, concaténation et multiplication. Lors de l'utilisation de tranche, la valeur assignée doit être un tableau du même type ; dans tous les autres cas, l'exception `TypeError` est levée. Les objets de tableau implémentent également l'interface tampon, et peuvent être utilisés partout où bytes-like objects sont supportés.

  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.