`numpy` — operaciones con arreglos compatibles con numpy#

El submódulo numpy de ulab proporciona una API compatible con numpy construida en torno al tipo de arreglo n-dimensional ndarray. Implementa un subconjunto cuidadosamente seleccionado de numpy de CPython: construcción de arreglos, operaciones matemáticas elemento a elemento, reducciones y estadísticas, álgebra lineal, FFT, generación de números aleatorios, ajuste polinómico y E/S básica.

El submódulo se importa convencionalmente como 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)))

Cada argumento dtype es una de las constantes enteras expuestas a nivel de módulo: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 y numpy.float (el valor predeterminado). El tipo de resultado ndarray hace referencia a numpy.ndarray.

Submódulos#

clase `ndarray` — el arreglo n-dimensional#

El ndarray es el contenedor n-dimensional y consciente del dtype que constituye el núcleo de numpy / ulab. Los datos se almacenan en un bloque contiguo cuya interpretación se describe mediante una pequeña cabecera (dtype, shape, strides, ndim, itemsize). Muchas operaciones –reshape, transpose, segmentación– solo ajustan esta cabecera y, por tanto, son muy económicas; los métodos que asignan almacenamiento nuevo (copy, flatten, la mayoría de las operaciones aritméticas) devuelven un nuevo arreglo denso.

El mismo tipo es accesible como ulab.ndarray, numpy.ndarray y (dentro de esta página) simplemente ndarray.

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

Crea un nuevo ndarray.

Parámetros:

values – Datos de origen. Ya sea otro ndarray (que se copia en profundidad, con conversión de tipo si dtype difiere) o cualquier iterable de MicroPython. Los iterables anidados producen arreglos multidimensionales; todos los iterables internos deben tener la misma longitud o se lanza un ValueError.
dtype – Tipo de elemento para el nuevo array. Uno de los enteros de código de tipo expuestos por numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 y numpy.float), o una instancia de dtype. El valor predeterminado es numpy.float.

La función de fábrica numpy.array es la forma convencional de crear un ndarray; reenvía a este constructor.

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

Intercambia el orden de bytes de cada elemento. Para arrays uint16, int16 y float, esto invierte el orden de bytes de cada elemento, lo cual es útil al consumir datos de periféricos cuyo orden de bytes no coincide con el del microcontrolador. Para tipos de un solo byte (bool, uint8, int8) esta operación no tiene efecto y devuelve una vista o copia.

Si inplace es False (el valor predeterminado), se devuelve un nuevo ndarray y el original queda intacto. Si inplace es True, los bytes de self se intercambian en el lugar y se devuelve una vista de self.

copy() → ndarray#: Devuelve una nueva copia densa y profunda del arreglo. La copia posee sus propios datos; las modificaciones realizadas en ella no afectan al original.

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

Devuelve una nueva copia unidimensional del arreglo.

Parámetros:: order – 'C' (el valor predeterminado) recorre los datos en orden C (el último eje varía más rápido); 'F' los recorre en orden Fortran (el primer eje varía más rápido).

reshape(shape: int | tuple[int, ...]) → ndarray#: Devuelve una vista del arreglo con una nueva forma. El número total de elementos debe permanecer invariable o se lanza un ValueError. Solo está disponible cuando ULAB_MAX_DIMS > 1. Equivalente a asignar a shape.

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

Ordena el arreglo en el lugar.

Parámetros:: axis – Eje a lo largo del cual ordenar. -1 (el valor predeterminado) ordena a lo largo del último eje; None primero aplana el arreglo y luego lo ordena.

tobytes() → bytearray#: Devuelve un bytearray que sirve de alias al búfer de datos subyacente del arreglo. Las escrituras a través del bytearray devuelto modifican el arreglo en el lugar. Lanza ValueError si el arreglo no es denso (por ejemplo, una vista segmentada).

tolist() → list#: Devuelve el contenido del arreglo como una list de Python (posiblemente anidada). La profundidad de anidamiento es igual a ndim.

transpose() → ndarray#: Devuelve la transpuesta del arreglo (ejes invertidos). Para arreglos unidimensionales esto devuelve self. Solo está disponible cuando ULAB_MAX_DIMS > 1. El atributo T es una abreviatura de este método.

dtype: dtype | int#: El tipo de datos de los elementos del arreglo. Devuelve una instancia de dtype cuando el firmware se compila con ULAB_HAS_DTYPE_OBJECT habilitado; de lo contrario, devuelve el código de tipo subyacente de un solo carácter como entero.

flat: flatiter#: Un iterador plano que produce cada elemento del arreglo en orden C. A diferencia de flatten(), iterar sobre flat no asigna un nuevo arreglo.

itemsize: int#: Tamaño en bytes de un único elemento del arreglo, derivado de dtype.

ndim: int#: Número de dimensiones del arreglo (longitud de shape).

shape: tuple[int, ...]#: Longitudes del arreglo a lo largo de cada eje. Asignar una tupla a shape cambia la forma del arreglo en el lugar (equivalente a reshape()).

size: int#: Número total de elementos en el arreglo (el producto de shape).

strides: tuple[int, ...]#: Número de bytes que hay que avanzar en memoria a lo largo de cada eje para alcanzar el siguiente elemento a lo largo de ese eje.

T: ndarray#: La transpuesta del arreglo; equivalente a transpose().

Operadores admitidos#

Las instancias de ndarray admiten los siguientes operadores. Los operadores binarios difunden sus operandos siguiendo las reglas estándar de difusión de numpy y siguen las reglas de promoción de tipos de numpy (p. ej. uint8 + int8 => int16, uint16 + int16 => float).

Aritmética (binaria): +, -, *, /, //, %, **. También se admiten los operandos reflejados (a la derecha) y las variantes en sitio +=, -=, *=, /=, %=, **=. Se aceptan las formas ndarray-con-ndarray y ndarray-con-escalar.

Comparación: ==, !=, <, <=, >, >=. Cada uno devuelve un ndarray booleano de la forma de difusión.

Bit a bit (solo arrays de enteros): &, |, ^. Aplicar estas operaciones a un array float genera TypeError.

Unarios: + (devuelve una copia), - (negación; en dtypes sin signo los valores se ajustan módulo \(2^N\)), abs() (valor absoluto elemento a elemento; en dtypes sin signo devuelve una copia sin cálculo), ~ (inversión a nivel de bits, solo dtypes enteros), len() (devuelve la longitud del primer eje).

Indexación y segmentación: a[i], a[i, j, ...], a[start:stop:step], la indexación por máscara booleana (a[mask]) y la indexación por arreglo de enteros (avanzada) se admiten todas tanto en lecturas como en escrituras.

Iteración: Iterar sobre un ndarray produce subarreglos a lo largo del primer eje (un elemento a la vez para arreglos 1-D). Use flat para iterar sobre cada elemento escalar independientemente de la dimensionalidad.

El operador de multiplicación de matrices @ no está implementado; use numpy.dot (np.dot(a, b)) en su lugar.

Los operadores de desplazamiento (<<, >>) no están implementados a nivel de operador. Use numpy.left_shift y numpy.right_shift para desplazamientos de enteros elemento a elemento.

Construcción de arreglos#

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray#: Construye un nuevo ndarray a partir de un iterable anidado de números. Constructor alternativo equivalente para numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray#: Devuelve valores espaciados uniformemente sobre el intervalo semiabierto [start, stop). Si solo se proporciona un argumento posicional, se trata como stop con start = 0. Si se omite dtype, se infiere a partir de las entradas (entero si start, stop y step son todos enteros y están dentro del rango).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray#: Si a ya es un ndarray cuyo dtype coincide con dtype (o dtype es None), devuelve a sin cambios; de lo contrario, crea un nuevo arreglo (con la conversión de dtype solicitada cuando se proporciona). Los iterables se convierten como en numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray#: Une una secuencia de ndarray a lo largo de un axis existente. Todos los arreglos de entrada deben compartir el mismo dtype, ndim y forma en todos los ejes excepto en axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray#: Para un a 2-D, devuelve un arreglo 1-D que contiene la k-ésima diagonal. Para un a 1-D, devuelve un arreglo cuadrado 2-D con a colocado en la k-ésima diagonal. k puede ser positivo (por encima de la diagonal principal) o negativo (por debajo).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Alias de zeros; devuelve un arreglo lleno de ceros de forma shape y dtype dtype. (ulab no deja el búfer sin inicializar).

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray#: Devuelve un arreglo 2-D de N x M (cuadrado N x N si M es None) con unos en la k-ésima diagonal y ceros en el resto.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray#: Interpreta un objeto que cumple el protocolo de búfer como un ndarray 1-D de tipo dtype. count es el número de elementos a leer (-1 lee todos los elementos disponibles); offset omite esa cantidad de bytes al inicio del búfer.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray#: Devuelve un nuevo arreglo de forma shape y dtype dtype con cada elemento establecido en fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]#: Devuelve num muestras equiespaciadas sobre el intervalo cerrado [start, stop] (o semiabierto si endpoint es False). Cuando retstep es True, devuelve una tupla (samples, step).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray#: Devuelve num muestras espaciadas uniformemente en una escala logarítmica: el resultado comienza en base ** start y termina en base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]#: Devuelve una tupla de matrices de coordenadas a partir de una secuencia de arreglos de coordenadas unidimensionales. Con indexing 'xy' (el valor predeterminado), las dos primeras entradas se tratan como coordenadas cartesianas y sus ejes de salida se intercambian; con 'ij' se utiliza la indexación de estilo matricial. La implementación se corresponde con el equivalente de NumPy con copy=True y sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Devuelve un nuevo arreglo de forma shape y dtype dtype lleno de unos.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Devuelve un nuevo arreglo de forma shape y dtype dtype lleno de ceros.

Inspección / impresión#

numpy.get_printoptions() → dict#: Devuelve las opciones actuales de impresión de arreglos como un diccionario con las claves threshold y edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None#: Establece las opciones de impresión de arreglos. threshold es el número máximo de elementos del arreglo que se imprimen por completo; edgeitems es el número de elementos mostrados en cada extremo de un eje cuando el arreglo se resume.

numpy.ndinfo(array: ndarray) → None#: Imprime información de diagnóstico (forma, strides, dtype, itemsize, …) sobre array.

numpy.size(a: ndarray, *, axis: int | None = None) → int#: Devuelve el número de elementos de a a lo largo de axis; si axis es None, devuelve el número total de elementos (el producto de ndarray.shape).

Comparación#

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float#: Recorta los valores de a de modo que a_min <= result <= a_max. Equivalente a maximum(a_min, minimum(a, a_max)); la difusión sigue las mismas reglas que minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: x1 == x2 elemento a elemento; devuelve un ndarray booleano (o un escalar bool si ambas entradas son escalares). Se proporciona por portabilidad: el operador == sobre arreglos da el mismo resultado.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: x1 != x2 elemento a elemento; la contraparte booleana de equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool#: Devuelve un arreglo (o escalar) booleano que es True donde la entrada es finita. Las entradas enteras siempre son finitas.

numpy.isinf(x: ndarray | int | float) → ndarray | bool#: Devuelve un arreglo (o escalar) booleano que es True donde la entrada es infinita. Las entradas enteras nunca son infinitas.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: Máximo elemento a elemento de dos arreglos / escalares. Los argumentos se difunden conjuntamente; si los dtypes difieren, la salida se promueve.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: Mínimo elemento a elemento de dos arreglos / escalares; contraparte de maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]#: Devuelve una tupla de ndarray, uno por cada dimensión de a, que contiene los índices de los elementos distintos de cero de a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray#: Devuelve un ndarray cuyos elementos provienen de x donde condition es verdadero, y de y en caso contrario. Las tres entradas se difunden conjuntamente; el dtype de salida es la promoción de x e y.

Reducciones numéricas#

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: Comprueba si todos los elementos a lo largo de axis se evalúan como True. Con axis=None (el valor predeterminado) se comprueba el arreglo aplanado y se devuelve un único bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: Comprueba si algún elemento a lo largo de axis se evalúa como True. Con axis=None se comprueba el arreglo aplanado.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: Devuelve el índice del elemento máximo a lo largo de axis. Con axis=None el arreglo se aplana y se devuelve un único entero.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: Devuelve el índice del elemento mínimo a lo largo de axis. Con axis=None el arreglo se aplana y se devuelve un único entero.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray#: Devuelve un ndarray de índices enteros sin signo cuyas entradas ordenan a en orden ascendente a lo largo de axis. El dtype de salida es uint16, por lo que ningún eje puede superar los 65535 elementos. axis=None no se admite.

numpy.cross(a: ndarray, b: ndarray) → ndarray#: Devuelve el producto vectorial de dos arreglos 1-D de longitud 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray#: Devuelve la n-ésima diferencia hacia adelante discreta de a a lo largo de axis. n debe estar en 0..9 (la plantilla de diferenciación se almacena en un int8); la longitud de axis se reduce en n. Las palabras clave prepend y append de numpy no están implementadas.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray#: Devuelve un nuevo arreglo con el orden de los elementos invertido a lo largo de axis; con axis=None el arreglo se invierte a lo largo de todos los ejes.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Devuelve el elemento máximo a lo largo de axis. Con axis=None (el valor predeterminado) el arreglo aplanado se reduce a un escalar. La palabra clave out de numpy no está implementada.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Devuelve el elemento mínimo a lo largo de axis; contraparte de max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float#: Devuelve la media aritmética a lo largo de axis. Con axis=None (el valor predeterminado) se devuelve la media del arreglo aplanado como un float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float#: Devuelve la mediana a lo largo de axis. Con axis=None el arreglo se aplana primero. El dtype de salida es siempre float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray#: Devuelve a con sus elementos rotados (desplazados cíclicamente) en shift posiciones. Con axis=None (el valor predeterminado) el arreglo se aplana primero. Los desplazamientos negativos rotan en la dirección opuesta.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray#: Devuelve una copia ordenada de a a lo largo de axis usando heap sort. Con axis=None el arreglo se aplana primero. Las palabras clave kind y order de numpy no están implementadas.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float#: Devuelve la desviación estándar a lo largo de axis. ddof son los grados de libertad delta: el divisor utilizado es N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Devuelve la suma a lo largo de axis. Con axis=None se devuelve el total del arreglo aplanado como un escalar.

Estadísticas#

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray#: Cuenta el número de apariciones de cada valor en el arreglo unidimensional de enteros no negativos x. El dtype de x debe ser uint8 o uint16. Si se proporciona weights, cada entrada de x aporta su peso correspondiente en lugar de 1 y la salida es de dtype float; de lo contrario, la salida es de dtype uint16. Si se proporciona minlength, el arreglo de salida tiene al menos esa cantidad de elementos (las entradas adicionales son cero).

numpy.trace(m: ndarray) → int | float#: Devuelve la suma de los elementos diagonales de la matriz cuadrada m. El tipo de retorno sigue el dtype de m (los arreglos enteros producen un entero, los arreglos float un float).

Transformación#

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray#: Devuelve segmentos de a seleccionados a lo largo de axis mediante la condición booleana condition. Con axis=None se utiliza el arreglo aplanado.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray#: Devuelve una copia de a con las entradas en indices eliminadas a lo largo de axis. Con axis=None el arreglo se aplana primero. Los índices negativos cuentan desde el final de axis; indices se ordena internamente antes de la eliminación.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float#: Devuelve el producto escalar de dos arreglos. Para dos arreglos 1-D este es el producto interno (un escalar float). Para arreglos 2-D esta es la multiplicación de matrices; las dimensiones internas deben coincidir. El resultado es siempre de dtype float.

Aproximación#

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray#: Interpolación lineal unidimensional. xp debe ser un arreglo 1-D monótonamente creciente de valores independientes; fp contiene los valores dependientes correspondientes; x son los puntos en los que se evalúa el interpolante. left y right anulan el valor devuelto para x < xp[0] y x > xp[-1] respectivamente (valores predeterminados: fp[0] y fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float#: Integra y usando la regla trapezoidal compuesta. Si se proporciona x, este aporta las posiciones de muestreo correspondientes a y; de lo contrario, se utiliza el espaciado dx. y (y x) deben ser 1-D.

Selección#

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray#: Toma elementos de a en los indices dados a lo largo de axis. Con axis=None se utiliza el arreglo aplanado. mode selecciona el comportamiento fuera de límites: "raise" (predeterminado: lanza ValueError), "wrap" (módulo la longitud del eje) o "clip" (recorta al rango válido; no se permiten índices negativos). Si se proporciona out, el resultado se escribe en él.

A nivel de bits#

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray#: AND a nivel de bits elemento a elemento de dos arreglos enteros; se admite la difusión. Un dtype no entero lanza una excepción.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray#: OR a nivel de bits elemento a elemento de dos arreglos enteros.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray#: XOR a nivel de bits elemento a elemento de dos arreglos enteros.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray#: Desplazamiento a nivel de bits elemento a elemento de x1 hacia la izquierda en x2 bits; ambos arreglos deben tener dtype entero.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray#: Desplazamiento a nivel de bits elemento a elemento de x1 hacia la derecha en x2 bits; ambos arreglos deben tener dtype entero.

Filtrado#

numpy.convolve(a: ndarray, v: ndarray) → ndarray#: Devuelve la convolución lineal discreta de dos arreglos 1-D. Solo se admite el modo "full"; la palabra clave mode de numpy no se acepta (otros modos pueden obtenerse segmentando el resultado completo). La longitud de salida es len(a) + len(v) - 1.

Polinómico#

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Ajusta un polinomio de grado deg a los puntos de datos (x, y) por mínimos cuadrados y devuelve los coeficientes del polinomio (de mayor grado primero). Si se omite x, se utiliza range(len(y)). Lanza ValueError si las longitudes de x e y difieren.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float#: Evalúa el polinomio cuyos coeficientes son p (de mayor grado primero) en x. Si x es un escalar se devuelve un float; de lo contrario, un ndarray.

E/S#

numpy.load(file: str) → ndarray#: Lee un arreglo previamente escrito con save desde file (el formato .npy independiente de la plataforma de numpy). La endianidad se convierte sobre la marcha si el orden de bytes del archivo difiere del del host.

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#: Lee datos numéricos de un archivo de texto file y los devuelve como un ndarray. delimiter tiene como valor predeterminado el espacio en blanco; comments es el marcador de comentario de línea; max_rows limita el número de filas de datos leídas (-1 para todas); usecols selecciona columnas por índice; skiprows omite esa cantidad de filas iniciales. Si dtype no es float, los valores se convierten mediante redondeo.

numpy.save(file: str, a: ndarray) → None#: Guarda a en file en el formato .npy independiente de la plataforma de numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None#: Escribe a en file como texto. delimiter separa los valores dentro de una fila; header y footer, si se proporcionan, se escriben antes/después de los datos, cada uno precedido por comments. Los valores se escriben como coma flotante.

Funciones universales#

Funciones matemáticas elemento a elemento. Cada una acepta un escalar o un ndarray y devuelve un resultado de forma coincidente (un escalar float para entrada escalar, un ndarray para entrada de arreglo). Cuando se llama con un ndarray, el resultado es un nuevo ndarray de coma flotante; se puede pasar una palabra clave out opcional para escribir el resultado en un ndarray float preasignado del mismo tamaño.

numpy.acos(x: ndarray | float, /) → ndarray | float#: Calcula el coseno inverso (arcocoseno) de cada elemento de x; el resultado está en radianes.

numpy.acosh(x: ndarray | float, /) → ndarray | float#: Calcula el coseno hiperbólico inverso de cada elemento de x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float#: Calcula la tangente inversa de dos argumentos atan2(y, x) elemento a elemento; admite la difusión entre las dos entradas.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray#: Redondea los elementos del ndarray x al número de decimals indicado; el primer argumento debe ser un ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float#: Calcula el seno inverso (arcoseno) de cada elemento de x; el resultado está en radianes.

numpy.asinh(x: ndarray | float, /) → ndarray | float#: Calcula el seno hiperbólico inverso de cada elemento de x.

numpy.atan(x: ndarray | float, /) → ndarray | float#: Calcula la tangente inversa (arcotangente) de cada elemento de x; el resultado está en radianes.

numpy.atanh(x: ndarray | float, /) → ndarray | float#: Calcula la tangente hiperbólica inversa de cada elemento de x.

numpy.ceil(x: ndarray | float, /) → ndarray | float#: Calcula el techo (el entero más pequeño no menor que el valor) de cada elemento de x.

numpy.cos(x: ndarray | float, /) → ndarray | float#: Calcula el coseno de cada elemento de x (en radianes).

numpy.cosh(x: ndarray | float, /) → ndarray | float#: Calcula el coseno hiperbólico de cada elemento de x.

numpy.degrees(x: ndarray | float, /) → ndarray | float#: Convierte cada elemento de x de radianes a grados.

numpy.exp(x: ndarray | float, /) → ndarray | float#: Calcula la exponencial e**x de cada elemento de x.

numpy.expm1(x: ndarray | float, /) → ndarray | float#: Calcula exp(x) - 1 de cada elemento de x con mayor precisión cerca de cero.

numpy.floor(x: ndarray | float, /) → ndarray | float#: Calcula el piso (el entero más grande no mayor que el valor) de cada elemento de x.

numpy.log(x: ndarray | float, /) → ndarray | float#: Calcula el logaritmo natural de cada elemento de x.

numpy.log10(x: ndarray | float, /) → ndarray | float#: Calcula el logaritmo en base 10 de cada elemento de x.

numpy.log2(x: ndarray | float, /) → ndarray | float#: Calcula el logaritmo en base 2 de cada elemento de x.

numpy.radians(x: ndarray | float, /) → ndarray | float#: Convierte cada elemento de x de grados a radianes.

numpy.sin(x: ndarray | float, /) → ndarray | float#: Calcula el seno de cada elemento de x (en radianes).

numpy.sinc(x: ndarray | float, /) → ndarray | float#: Calcula la función sinc normalizada sin(pi*x) / (pi*x) de cada elemento de x.

numpy.sinh(x: ndarray | float, /) → ndarray | float#: Calcula el seno hiperbólico de cada elemento de x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float#: Calcula la raíz cuadrada de cada elemento de x.

numpy.tan(x: ndarray | float, /) → ndarray | float#: Calcula la tangente de cada elemento de x (en radianes).

numpy.tanh(x: ndarray | float, /) → ndarray | float#: Calcula la tangente hiperbólica de cada elemento de x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable#: Devuelve un invocable que aplica la función de Python f elemento a elemento a un escalar, iterable o ndarray; otypes selecciona el dtype de salida (float por defecto).

Constantes#

numpy.e: float#: El número de Euler \(e \approx 2.71828\).

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

numpy.inf: float#: Infinito positivo de coma flotante IEEE-754.

numpy.nan: float#: «No es un número» (NaN) de coma flotante IEEE-754.

numpy.bool: int#: Código de dtype para arreglos booleanos (almacenados como uint8).

numpy.uint8: int#: Código de dtype para arreglos de enteros sin signo de 8 bits.

numpy.int8: int#: Código de dtype para arreglos de enteros con signo de 8 bits.

numpy.uint16: int#: Código de dtype para arreglos de enteros sin signo de 16 bits.

numpy.int16: int#: Código de dtype para arreglos de enteros con signo de 16 bits.

numpy.float: int#: Código de dtype para arreglos de coma flotante de 32 bits.

numpy — operaciones con arreglos compatibles con numpy#