`numpy` — opérations sur tableaux compatibles numpy¶

Le sous-module numpy de ulab fournit une API compatible numpy construite autour du type de tableau n-dimensionnel ndarray. Il implémente un sous-ensemble soigneusement choisi de numpy de CPython : construction de tableaux, opérations mathématiques élément par élément, réductions et statistiques, algèbre linéaire, FFT, génération de nombres aléatoires, ajustement polynomial et entrées/sorties de base.

Le sous-module est conventionnellement importé sous le nom np

from ulab import numpy as np

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.linspace(0, 1, num=5)
c = np.dot(a.reshape((2, 2)), a.reshape((2, 2)))

Chaque argument dtype est l’une des constantes entières exposées au niveau du module : numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (la valeur par défaut) et (lorsque la prise en charge des complexes est compilée) numpy.complex. Le type de résultat ndarray fait référence à numpy.ndarray.

Sous-modules¶

classe `ndarray` — le tableau n-dimensionnel¶

Le ndarray est le conteneur n-dimensionnel et conscient du dtype au cœur de numpy / ulab. Les données sont stockées dans un bloc contigu dont l’interprétation est décrite par un petit en-tête (dtype, shape, strides, ndim, itemsize). De nombreuses opérations – reshape, transpose, le découpage – ajustent uniquement cet en-tête et sont donc très peu coûteuses ; les méthodes qui allouent un nouveau stockage (copy, flatten, la plupart des opérations arithmétiques) renvoient un nouveau tableau dense.

Le même type est accessible sous les noms ulab.ndarray, numpy.ndarray et (au sein de cette page) simplement ndarray.

class numpy.ndarray(values: ndarray | bytes | list | tuple, *, dtype: int = numpy.float)¶

Crée un nouveau ndarray.

Paramètres:

values – Données sources. Soit un autre ndarray (qui est copié en profondeur, avec conversion de type si dtype diffère), soit n’importe quel itérable MicroPython. Les itérables imbriqués produisent des tableaux multidimensionnels ; les itérables internes doivent tous avoir la même longueur, sinon une exception ValueError est levée.
dtype – Type d’élément du nouveau tableau. L’un des entiers de code de type exposés par numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float et – lorsqu’elle est prise en charge – numpy.complex), ou une instance de dtype. La valeur par défaut est numpy.float.

La fonction de fabrique numpy.array est la manière conventionnelle de créer un ndarray ; elle transmet à ce constructeur.

byteswap(*, inplace: bool = False) → ndarray¶

Inverse l’ordre des octets de chaque élément. Pour les tableaux uint16, int16, float et complex, ceci inverse l’ordre des octets par élément, ce qui est utile lors de la consommation de données provenant de périphériques dont le boutisme ne correspond pas à celui du microcontrôleur. Pour les dtypes à octet unique (bool, uint8, int8), il s’agit d’une opération sans effet qui renvoie une vue ou une copie.

Si inplace vaut False (la valeur par défaut), un nouveau ndarray est renvoyé et l’original reste intact. Si inplace vaut True, les octets de self sont inversés sur place et une vue de self est renvoyée.

copy() → ndarray¶: Renvoie une nouvelle copie dense et en profondeur du tableau. La copie possède ses propres données ; les modifications qui lui sont apportées n’affectent pas l’original.

flatten(*, order: str = 'C') → ndarray¶

Renvoie une nouvelle copie unidimensionnelle du tableau.

Paramètres:: order – 'C' (la valeur par défaut) parcourt les données dans l’ordre C (le dernier axe varie le plus vite) ; 'F' les parcourt dans l’ordre Fortran (le premier axe varie le plus vite).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Renvoie une vue du tableau avec une nouvelle forme. Le nombre total d’éléments doit rester inchangé, sinon une exception ValueError est levée. Disponible uniquement lorsque ULAB_MAX_DIMS > 1. Équivaut à une affectation à shape.

sort(*, axis: int | None = -1) → None¶

Trie le tableau sur place.

Paramètres:: axis – Axe selon lequel trier. -1 (la valeur par défaut) trie selon le dernier axe ; None aplatit d’abord le tableau, puis le trie.

tobytes() → bytearray¶: Renvoie un bytearray qui aliasse le tampon de données sous-jacent du tableau. Les écritures via le bytearray renvoyé modifient le tableau sur place. Lève une exception ValueError si le tableau n’est pas dense (par exemple une vue découpée).

tolist() → list¶: Renvoie le contenu du tableau sous la forme d’une list Python (éventuellement imbriquée). La profondeur d’imbrication est égale à ndim.

transpose() → ndarray¶: Renvoie la transposée du tableau (axes inversés). Pour les tableaux unidimensionnels, ceci renvoie self. Disponible uniquement lorsque ULAB_MAX_DIMS > 1. L’attribut T est un raccourci pour cette méthode.

dtype: dtype | int¶: Le type de données des éléments du tableau. Renvoie une instance de dtype lorsque le micrologiciel est compilé avec ULAB_HAS_DTYPE_OBJECT activé, sinon le code de type sous-jacent à un seul caractère sous forme d’entier.

flat: flatiter¶: Un itérateur plat qui produit chaque élément du tableau dans l’ordre C. Contrairement à flatten(), l’itération sur flat n’alloue pas de nouveau tableau.

itemsize: int¶: Taille en octets d’un seul élément du tableau, dérivée de dtype.

ndim: int¶: Nombre de dimensions du tableau (longueur de shape).

shape: tuple[int, ...]¶: Longueurs du tableau selon chaque axe. L’affectation d’un tuple à shape redimensionne le tableau sur place (équivaut à reshape()).

size: int¶: Nombre total d’éléments dans le tableau (le produit de shape).

strides: tuple[int, ...]¶: Nombre d’octets à franchir en mémoire selon chaque axe pour atteindre l’élément suivant le long de cet axe.

T: ndarray¶: La transposée du tableau ; équivaut à transpose().

real: ndarray¶: La partie réelle d’un tableau complexe, renvoyée sous forme de ndarray float. Pour les tableaux réels, il s’agit d’une copie de self avec le même dtype. Disponible uniquement lorsque le micrologiciel a été compilé avec la prise en charge des complexes.

imag: ndarray¶: La partie imaginaire d’un tableau complexe, renvoyée sous forme de ndarray float. Pour les tableaux réels, il s’agit d’un tableau de zéros avec le même dtype que self. Disponible uniquement lorsque le micrologiciel a été compilé avec la prise en charge des complexes.

Opérateurs pris en charge¶

Les instances de ndarray prennent en charge les opérateurs suivants. Les opérateurs binaires diffusent leurs opérandes selon les règles standard de diffusion (broadcasting) de numpy et suivent les règles de promotion de type de numpy (par exemple uint8 + int8 => int16, uint16 + int16 => float) ; les opérations impliquant un opérande complexe produisent un résultat complexe.

Arithmétique (binaire) : +, -, *, /, //, %, **. Les opérandes réfléchis (à droite) et les variantes sur place +=, -=, *=, /=, %=, **= sont également pris en charge. Les formes ndarray-avec-ndarray et ndarray-avec-scalaire sont toutes deux acceptées. La division entière (//) et l’opérateur modulo (%) ne sont pas implémentés pour les tableaux complex.

Comparaison : ==, !=, <, <=, >, >=. Chacun renvoie un ndarray booléen de la forme diffusée.

Opérations bit à bit (tableaux entiers uniquement) : &, |, ^. L’application de ces opérations à un tableau float ou complex lève une exception TypeError.

Unaire : + (renvoie une copie), - (négation ; sur les dtypes non signés, les valeurs bouclent modulo \(2^N\)), abs() (valeur absolue élément par élément ; sur les dtypes non signés renvoie une copie sans calcul), ~ (inversion bit à bit, dtypes entiers uniquement), len() (renvoie la longueur du premier axe).

Indexation et découpage : a[i], a[i, j, ...], a[start:stop:step], l’indexation par masque booléen (a[mask]) et l’indexation par tableau d’entiers (indexation avancée) sont toutes prises en charge en lecture comme en écriture.

Itération : L’itération sur un ndarray produit des sous-tableaux le long du premier axe (un élément à la fois pour les tableaux 1-D). Utilisez flat pour itérer sur chaque élément scalaire indépendamment de la dimensionnalité.

L’opérateur de multiplication matricielle @ n’est pas implémenté ; utilisez plutôt numpy.dot (np.dot(a, b)).

Les opérateurs de décalage (<<, >>) ne sont pas implémentés au niveau des opérateurs. Utilisez numpy.left_shift et numpy.right_shift pour les décalages d’entiers élément par élément.

Construction de tableaux¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Construit un nouveau ndarray à partir d’un itérable imbriqué de nombres. Constructeur alternatif équivalent pour numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Renvoie des valeurs régulièrement espacées sur l’intervalle semi-ouvert [start, stop). Si un seul argument positionnel est fourni, il est traité comme stop avec start = 0. Si dtype est omis, il est déduit des entrées (entier si start, stop et step sont tous des entiers et dans la plage).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Si a est déjà un ndarray dont le dtype correspond à dtype (ou si dtype vaut None), renvoie a inchangé ; sinon, crée un nouveau tableau (avec la conversion de dtype demandée si elle est fournie). Les itérables sont convertis comme dans numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Joint une séquence de ndarray selon un axis existant. Tous les tableaux d’entrée doivent partager les mêmes dtype, ndim et forme sur tous les axes autres que axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Pour un a en 2-D, renvoie un tableau 1-D contenant la k-ième diagonale. Pour un a en 1-D, renvoie un tableau carré 2-D avec a placé sur la k-ième diagonale. k peut être positif (au-dessus de la diagonale principale) ou négatif (en dessous).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Alias de zeros ; renvoie un tableau rempli de zéros de forme shape et de dtype dtype. (ulab ne laisse pas le tampon non initialisé.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Renvoie un tableau 2-D N x M (carré N x N si M vaut None) avec des uns sur la k-ième diagonale et des zéros ailleurs.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Interprète un objet du protocole tampon comme un ndarray 1-D de dtype dtype. count est le nombre d’éléments à lire (-1 lit tous les éléments disponibles) ; offset saute ce nombre d’octets au début du tampon.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Renvoie un nouveau tableau de forme shape et de dtype dtype dont chaque élément vaut fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Renvoie num échantillons régulièrement espacés sur l’intervalle fermé [start, stop] (ou semi-ouvert si endpoint vaut False). Lorsque retstep vaut True, renvoie un tuple (samples, step). Des valeurs start/stop complexes produisent un tableau complexe (lorsque la prise en charge des complexes est activée).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Renvoie num échantillons régulièrement espacés sur une échelle logarithmique : le résultat commence à base ** start et se termine à base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Renvoie un tuple de matrices de coordonnées à partir d’une séquence de tableaux de coordonnées unidimensionnels. Avec indexing 'xy' (la valeur par défaut), les deux premières entrées sont traitées comme des coordonnées cartésiennes et leurs axes de sortie sont échangés ; avec 'ij', l’indexation de type matriciel est utilisée. L’implémentation correspond à l’équivalent NumPy avec copy=True et sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Renvoie un nouveau tableau de forme shape et de dtype dtype rempli de uns.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Renvoie un nouveau tableau de forme shape et de dtype dtype rempli de zéros.

Inspection / affichage¶

numpy.get_printoptions() → dict¶: Renvoie les options d’affichage des tableaux actuelles sous forme de dict avec les clés threshold et edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Définit les options d’affichage des tableaux. threshold est le nombre maximal d’éléments du tableau affichés en entier ; edgeitems est le nombre d’éléments affichés à chaque extrémité d’un axe lorsque le tableau est résumé.

numpy.ndinfo(array: ndarray) → None¶: Affiche des informations de diagnostic (forme, strides, dtype, itemsize, …) sur array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Renvoie le nombre d’éléments de a le long de axis ; si axis vaut None, renvoie le nombre total d’éléments (le produit de ndarray.shape).

Comparaison¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Borne les valeurs de a de sorte que a_min <= result <= a_max. Équivaut à maximum(a_min, minimum(a, a_max)) ; la diffusion suit les mêmes règles que minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: x1 == x2 élément par élément ; renvoie un ndarray booléen (ou un scalaire bool si les deux entrées sont des scalaires). Fourni pour la portabilité – l’opérateur == sur les tableaux donne le même résultat.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: x1 != x2 élément par élément ; le pendant booléen de equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Renvoie un tableau booléen (ou un scalaire) qui vaut True là où l’entrée est finie. Les entrées entières sont toujours finies.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Renvoie un tableau booléen (ou un scalaire) qui vaut True là où l’entrée est infinie. Les entrées entières ne sont jamais infinies.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Maximum élément par élément de deux tableaux / scalaires. Les arguments sont diffusés ensemble ; si les dtypes diffèrent, la sortie est promue.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Minimum élément par élément de deux tableaux / scalaires ; le pendant de maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Renvoie un tuple de ndarray, un par dimension de a, contenant les indices des éléments non nuls de a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Renvoie un ndarray dont les éléments proviennent de x là où condition est vraie, et de y sinon. Les trois entrées sont diffusées ensemble ; le dtype de sortie est la promotion de x et y.

Réductions numériques¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Teste si tous les éléments le long de axis s’évaluent à True. Avec axis=None (la valeur par défaut), le tableau aplati est testé et un seul bool est renvoyé.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Teste si au moins un élément le long de axis s’évalue à True. Avec axis=None, le tableau aplati est testé.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Renvoie l’indice de l’élément maximal le long de axis. Avec axis=None, le tableau est aplati et un seul entier est renvoyé.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Renvoie l’indice de l’élément minimal le long de axis. Avec axis=None, le tableau est aplati et un seul entier est renvoyé.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Renvoie un ndarray d’indices entiers non signés dont les entrées trient a dans l’ordre croissant le long de axis. Le dtype de sortie est uint16, donc aucun axe ne peut dépasser 65535 éléments. axis=None n’est pas pris en charge.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Renvoie le produit vectoriel de deux tableaux 1-D de longueur 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Renvoie la n-ième différence finie discrète avant de a le long de axis. n doit être dans 0..9 (le gabarit de différentiation est stocké dans un int8) ; la longueur de axis diminue de n. Les mots-clés numpy prepend et append ne sont pas implémentés.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Renvoie un nouveau tableau dont l’ordre des éléments est inversé le long de axis ; avec axis=None, le tableau est inversé selon chaque axe.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Renvoie l’élément maximal le long de axis. Avec axis=None (la valeur par défaut), le tableau aplati est réduit à un scalaire. Le mot-clé numpy out n’est pas implémenté.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Renvoie l’élément minimal le long de axis ; le pendant de max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Renvoie la moyenne arithmétique le long de axis. Avec axis=None (la valeur par défaut), la moyenne du tableau aplati est renvoyée sous forme de float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Renvoie la médiane le long de axis. Avec axis=None, le tableau est d’abord aplati. Le dtype de sortie est toujours float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Renvoie a avec ses éléments décalés (cycliquement) de shift positions. Avec axis=None (la valeur par défaut), le tableau est d’abord aplati. Les décalages négatifs effectuent la rotation dans le sens opposé.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Renvoie une copie triée de a le long de axis à l’aide du tri par tas. Avec axis=None, le tableau est d’abord aplati. Les mots-clés numpy kind et order ne sont pas implémentés.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Renvoie l’écart-type le long de axis. ddof est le nombre de degrés de liberté delta – le diviseur utilisé est N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Renvoie la somme le long de axis. Avec axis=None, le total du tableau aplati est renvoyé sous forme de scalaire.

Statistiques¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Compte le nombre d’occurrences de chaque valeur dans le tableau d’entiers unidimensionnel et non négatif x. Le dtype de x doit être uint8 ou uint16. Si weights est fourni, chaque entrée de x contribue son poids correspondant plutôt que 1 et la sortie est de dtype float ; sinon la sortie est de dtype uint16. Si minlength est fourni, le tableau de sortie comporte au moins ce nombre d’éléments (les entrées supplémentaires sont nulles).

numpy.trace(m: ndarray) → int | float¶: Renvoie la somme des éléments diagonaux de la matrice carrée m. Le type de retour suit le dtype de m (les tableaux entiers produisent un int, les tableaux float un float).

Transformation¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Renvoie des tranches de a sélectionnées le long de axis par la condition booléenne. Avec axis=None, le tableau aplati est utilisé.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Renvoie une copie de a dont les entrées aux indices indices sont supprimées le long de axis. Avec axis=None, le tableau est d’abord aplati. Les indices négatifs comptent à partir de la fin de axis ; indices est trié en interne avant la suppression.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Renvoie le produit scalaire de deux tableaux. Pour deux tableaux 1-D, il s’agit du produit interne (un scalaire float). Pour les tableaux 2-D, il s’agit de la multiplication matricielle ; les dimensions internes doivent correspondre. Le résultat est toujours de dtype float.

Approximation¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Interpolation linéaire unidimensionnelle. xp doit être un tableau 1-D de valeurs indépendantes strictement croissant ; fp contient les valeurs dépendantes correspondantes ; x sont les points auxquels l’interpolant est évalué. left et right remplacent respectivement la valeur renvoyée pour x < xp[0] et x > xp[-1] (valeurs par défaut : fp[0] et fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Intègre y à l’aide de la règle composite des trapèzes. Si x est fourni, il indique les positions des échantillons correspondant à y ; sinon, l’espacement dx est utilisé. y (et x) doivent être 1-D.

Sélection¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Prélève des éléments de a aux indices indices fournis le long de axis. Avec axis=None, le tableau aplati est utilisé. mode sélectionne le comportement hors limites : "raise" (par défaut – lève une exception ValueError), "wrap" (modulo la longueur de l’axe) ou "clip" (borne à la plage valide ; les indices négatifs ne sont pas autorisés). Si out est fourni, le résultat y est écrit.

Opérations bit à bit¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: ET bit à bit élément par élément de deux tableaux entiers ; la diffusion est prise en charge. Un dtype non entier lève une exception.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: OU bit à bit élément par élément de deux tableaux entiers.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: OU exclusif (XOR) bit à bit élément par élément de deux tableaux entiers.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Décalage bit à bit élément par élément de x1 vers la gauche de x2 bits ; les deux tableaux doivent avoir un dtype entier.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Décalage bit à bit élément par élément de x1 vers la droite de x2 bits ; les deux tableaux doivent avoir un dtype entier.

Filtrage¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Renvoie la convolution linéaire discrète de deux tableaux 1-D. Seul le mode "full" est pris en charge ; le mot-clé numpy mode n’est pas accepté (les autres modes peuvent être obtenus en découpant le résultat complet). La longueur de sortie est len(a) + len(v) - 1.

Polynôme¶

numpy.polyfit(x: ndarray | list | tuple, y: ndarray | list | tuple, deg: int) → ndarray¶

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Ajuste un polynôme de degré deg aux points de données (x, y) par moindres carrés et renvoie les coefficients du polynôme (degré le plus élevé en premier). Si x est omis, range(len(y)) est utilisé. Lève une exception ValueError si les longueurs de x et y diffèrent.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Évalue le polynôme dont les coefficients sont p (degré le plus élevé en premier) en x. Si x est un scalaire, un float est renvoyé, sinon un ndarray.

Entrées/sorties¶

numpy.load(file: str) → ndarray¶: Lit un tableau préalablement écrit avec save depuis file (le format .npy indépendant de la plateforme de numpy). Le boutisme est converti à la volée si l’ordre des octets du fichier diffère de celui de l’hôte.

numpy.loadtxt(file: str, *, delimiter: str | None = None, comments: str = '#', max_rows: int = -1, usecols: int | ndarray | list | tuple | None = None, dtype: int = float, skiprows: int = 0) → ndarray¶: Lit des données numériques depuis un fichier texte file et les renvoie sous forme de ndarray. delimiter vaut par défaut l’espace blanc ; comments est le marqueur de commentaire de ligne ; max_rows limite le nombre de lignes de données lues (-1 pour toutes) ; usecols sélectionne les colonnes par indice ; skiprows saute ce nombre de lignes initiales. Si dtype n’est pas float, les valeurs sont converties par arrondi.

numpy.save(file: str, a: ndarray) → None¶: Enregistre a dans file au format .npy indépendant de la plateforme de numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Écrit a dans file sous forme de texte. delimiter sépare les valeurs au sein d’une ligne ; header et footer, s’ils sont fournis, sont écrits avant/après les données, chacun préfixé par comments. Les valeurs sont écrites en virgule flottante.

Fonctions d’aide pour les complexes¶

Ces fonctions ne sont disponibles que lorsque ulab a été compilé avec la prise en charge des complexes (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Renvoie la partie réelle de val. Pour une entrée de dtype réel, renvoie une copie en préservant le dtype ; pour une entrée complexe, renvoie un ndarray float.

numpy.imag(val: ndarray) → ndarray¶: Renvoie la partie imaginaire de val. Pour une entrée de dtype réel, renvoie un tableau de zéros avec le même dtype ; pour une entrée complexe, renvoie un ndarray float.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Renvoie le conjugué complexe de val. Les entrées à valeurs réelles sont renvoyées inchangées.

numpy.sort_complex(a: ndarray) → ndarray¶: Trie le tableau 1-D a d’abord par partie réelle, puis par partie imaginaire. Le résultat est toujours de dtype complexe, même si a était à valeurs réelles.

Fonctions universelles¶

Fonctions mathématiques élément par élément. Chacune accepte un scalaire ou un ndarray et renvoie un résultat de forme correspondante (un scalaire float pour une entrée scalaire, un ndarray pour une entrée tableau). Lorsqu’elle est appelée avec un ndarray, le résultat est un nouveau ndarray à virgule flottante ; un mot-clé optionnel out peut être passé pour écrire le résultat dans un ndarray float préalloué de même taille.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Calcule le cosinus inverse (arc cosinus) de chaque élément de x ; le résultat est en radians.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Calcule le cosinus hyperbolique inverse de chaque élément de x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Calcule l’arc tangente à deux arguments atan2(y, x) élément par élément ; prend en charge la diffusion entre les deux entrées.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Arrondit les éléments du ndarray x au nombre de décimales decimals indiqué ; le premier argument doit être un ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Calcule le sinus inverse (arc sinus) de chaque élément de x ; le résultat est en radians.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Calcule le sinus hyperbolique inverse de chaque élément de x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Calcule la tangente inverse (arc tangente) de chaque élément de x ; le résultat est en radians.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Calcule la tangente hyperbolique inverse de chaque élément de x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Calcule le plafond (le plus petit entier non inférieur à la valeur) de chaque élément de x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Calcule le cosinus de chaque élément de x (en radians).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Calcule le cosinus hyperbolique de chaque élément de x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Convertit chaque élément de x des radians vers les degrés.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Calcule l’exponentielle e**x de chaque élément de x ; peut renvoyer un ndarray complexe lorsqu’une entrée complexe est fournie (si la prise en charge des complexes est activée).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Calcule exp(x) - 1 de chaque élément de x avec une précision améliorée près de zéro.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Calcule le plancher (le plus grand entier non supérieur à la valeur) de chaque élément de x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: Calcule le logarithme naturel de chaque élément de x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Calcule le logarithme en base 10 de chaque élément de x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Calcule le logarithme en base 2 de chaque élément de x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Convertit chaque élément de x des degrés vers les radians.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Calcule le sinus de chaque élément de x (en radians).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Calcule la fonction sinc normalisée sin(pi*x) / (pi*x) de chaque élément de x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Calcule le sinus hyperbolique de chaque élément de x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Calcule la racine carrée de chaque élément de x ; passez dtype=numpy.complex pour obtenir des résultats complexes pour les entrées réelles négatives (si la prise en charge des complexes est activée).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Calcule la tangente de chaque élément de x (en radians).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Calcule la tangente hyperbolique de chaque élément de x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Renvoie un objet appelable qui applique la fonction Python f élément par élément à un scalaire, un itérable ou un ndarray ; otypes sélectionne le dtype de sortie (float par défaut).

Constantes¶

numpy.e: float¶: Le nombre d’Euler \(e \approx 2.71828\).

numpy.pi: float¶: \(\pi \approx 3.14159\).

numpy.inf: float¶: Infini positif en virgule flottante IEEE-754.

numpy.nan: float¶: Le « pas un nombre » (NaN) en virgule flottante IEEE-754.

numpy.bool: int¶: Code de dtype pour les tableaux booléens (stockés sous forme uint8).

numpy.uint8: int¶: Code de dtype pour les tableaux d’entiers 8 bits non signés.

numpy.int8: int¶: Code de dtype pour les tableaux d’entiers 8 bits signés.

numpy.uint16: int¶: Code de dtype pour les tableaux d’entiers 16 bits non signés.

numpy.int16: int¶: Code de dtype pour les tableaux d’entiers 16 bits signés.

numpy.float: int¶: Code de dtype pour les tableaux en virgule flottante 32 bits.

numpy — opérations sur tableaux compatibles numpy¶