`numpy` — operazioni su array compatibili con numpy¶

Il sottomodulo numpy di ulab fornisce un’API compatibile con numpy costruita attorno al tipo di array n-dimensionale ndarray. Implementa un sottoinsieme selezionato di numpy di CPython: costruzione di array, operazioni matematiche elemento per elemento, riduzioni e statistiche, algebra lineare, FFT, generazione di numeri casuali, fitting polinomiale e I/O di base.

Per convenzione il sottomodulo viene importato come 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)))

Ogni argomento dtype è una delle costanti intere esposte a livello di modulo: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (il valore predefinito) e (quando il supporto ai numeri complessi è compilato) numpy.complex. Il tipo di risultato ndarray si riferisce a numpy.ndarray.

Sottomoduli¶

classe `ndarray` — l’array n-dimensionale¶

L”ndarray è il contenitore n-dimensionale e consapevole del dtype al centro di numpy / ulab. I dati sono memorizzati in un blocco contiguo la cui interpretazione è descritta da una piccola intestazione (dtype, shape, strides, ndim, itemsize). Molte operazioni – reshape, transpose, slicing – modificano solo questa intestazione e sono quindi molto economiche; i metodi che allocano nuova memoria (copy, flatten, la maggior parte dell’aritmetica) restituiscono un nuovo array denso.

Lo stesso tipo è raggiungibile come ulab.ndarray, numpy.ndarray e (all’interno di questa pagina) semplicemente ndarray.

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

Crea un nuovo ndarray.

Parametri:

values – Dati di origine. Possono essere un altro ndarray (che viene copiato in profondità, con conversione di tipo se dtype differisce) o qualsiasi iterabile di MicroPython. Gli iterabili annidati producono array multidimensionali; gli iterabili interni devono avere tutti la stessa lunghezza, altrimenti viene sollevato un ValueError.
dtype – Tipo degli elementi del nuovo array. Uno degli interi codice-tipo esposti da numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float e – quando supportato – numpy.complex), oppure un’istanza dtype. Il valore predefinito è numpy.float.

La funzione factory numpy.array è il modo convenzionale per creare un ndarray; inoltra a questo costruttore.

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

Scambia l’ordine dei byte di ogni elemento. Per gli array uint16, int16, float e complex questo inverte l’ordine dei byte di ciascun elemento, il che è utile quando si consumano dati da periferiche la cui endianness non corrisponde a quella del microcontrollore. Per i dtype a singolo byte (bool, uint8, int8) è un’operazione nulla che restituisce una vista o una copia.

Se inplace è False (il valore predefinito) viene restituito un nuovo ndarray e l’originale rimane intatto. Se inplace è True i byte di self vengono scambiati sul posto e viene restituita una vista di self.

copy() → ndarray¶: Restituisce una nuova copia profonda e densa dell’array. La copia possiede i propri dati; le modifiche ad essa non influiscono sull’originale.

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

Restituisce una nuova copia monodimensionale dell’array.

Parametri:: order – 'C' (il valore predefinito) percorre i dati in ordine C (l’ultimo asse varia più rapidamente); 'F' li percorre in ordine Fortran (il primo asse varia più rapidamente).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Restituisce una vista dell’array con una nuova forma. Il numero totale di elementi deve rimanere invariato, altrimenti viene sollevato un ValueError. Disponibile solo quando ULAB_MAX_DIMS > 1. Equivale ad assegnare a shape.

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

Ordina l’array sul posto.

Parametri:: axis – Asse lungo il quale ordinare. -1 (il valore predefinito) ordina lungo l’ultimo asse; None prima appiattisce l’array e poi lo ordina.

tobytes() → bytearray¶: Restituisce un bytearray che fa da alias al buffer di dati sottostante dell’array. Le scritture attraverso il bytearray restituito modificano l’array sul posto. Solleva ValueError se l’array non è denso (ad esempio una vista ottenuta con slicing).

tolist() → list¶: Restituisce il contenuto dell’array come list Python (eventualmente annidata). La profondità di annidamento è pari a ndim.

transpose() → ndarray¶: Restituisce la trasposta dell’array (assi invertiti). Per gli array monodimensionali restituisce self. Disponibile solo quando ULAB_MAX_DIMS > 1. L’attributo T è una scorciatoia per questo metodo.

dtype: dtype | int¶: Il tipo di dato degli elementi dell’array. Restituisce un’istanza dtype quando il firmware è compilato con ULAB_HAS_DTYPE_OBJECT abilitato, altrimenti il codice-tipo sottostante a singolo carattere come intero.

flat: flatiter¶: Un iteratore piatto che restituisce ogni elemento dell’array in ordine C. A differenza di flatten(), iterare su flat non alloca un nuovo array.

itemsize: int¶: Dimensione in byte di un singolo elemento dell’array, derivata da dtype.

ndim: int¶: Numero di dimensioni dell’array (lunghezza di shape).

shape: tuple[int, ...]¶: Lunghezze dell’array lungo ciascun asse. L’assegnazione di una tupla a shape rimodella l’array sul posto (equivalente a reshape()).

size: int¶: Numero totale di elementi nell’array (il prodotto di shape).

strides: tuple[int, ...]¶: Numero di byte da avanzare in memoria lungo ciascun asse per raggiungere l’elemento successivo lungo quell’asse.

T: ndarray¶: La trasposta dell’array; equivalente a transpose().

real: ndarray¶: La parte reale di un array complesso, restituita come ndarray float. Per gli array reali è una copia di self con lo stesso dtype. Disponibile solo quando il firmware è stato compilato con il supporto ai numeri complessi.

imag: ndarray¶: La parte immaginaria di un array complesso, restituita come ndarray float. Per gli array reali è un array di zeri con lo stesso dtype di self. Disponibile solo quando il firmware è stato compilato con il supporto ai numeri complessi.

Operatori supportati¶

Le istanze ndarray supportano i seguenti operatori. Gli operatori binari eseguono il broadcasting dei loro operandi secondo le regole standard di broadcasting di numpy e seguono le regole di upcasting di numpy (ad esempio uint8 + int8 => int16, uint16 + int16 => float); le operazioni che coinvolgono un operando complesso producono un risultato complesso.

Aritmetici (binari): +, -, *, /, //, %, **. Sono supportati anche gli operandi riflessi (a destra) e le varianti sul posto +=, -=, *=, /=, %=, **=. Sono accettate sia le forme ndarray-con-ndarray sia ndarray-con-scalare. La divisione intera (//) e l’operatore modulo (%) non sono implementati per gli array complex.

Confronto: ==, !=, <, <=, >, >=. Ciascuno restituisce un ndarray booleano della forma risultante dal broadcast.

Bit a bit (solo array interi): &, |, ^. Applicarli a un array float o complex solleva TypeError.

Unari: + (restituisce una copia), - (negazione; sui dtype senza segno i valori si avvolgono modulo \(2^N\)), abs() (valore assoluto elemento per elemento; sui dtype senza segno restituisce una copia senza calcolo), ~ (inversione bit a bit, solo dtype interi), len() (restituisce la lunghezza del primo asse).

Indicizzazione e slicing: a[i], a[i, j, ...], a[start:stop:step], l’indicizzazione con maschera booleana (a[mask]) e l’indicizzazione con array di interi (fancy) sono tutte supportate sia in lettura sia in scrittura.

Iterazione: Iterare su un ndarray restituisce sotto-array lungo il primo asse (un elemento alla volta per gli array 1-D). Usa flat per iterare su ogni elemento scalare indipendentemente dalla dimensionalità.

L’operatore di moltiplicazione matriciale @ non è implementato; usa invece numpy.dot (np.dot(a, b)).

Gli operatori di shift (<<, >>) non sono implementati a livello di operatore. Usa numpy.left_shift e numpy.right_shift per gli shift di interi elemento per elemento.

Costruzione di array¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Costruisce un nuovo ndarray da un iterabile annidato di numeri. Costruttore alternativo equivalente per numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Restituisce valori spaziati uniformemente sull’intervallo semiaperto [start, stop). Se viene fornito un solo argomento posizionale, viene trattato come stop con start = 0. Se dtype è omesso, viene dedotto dagli input (intero se start, stop, step sono tutti interi e nell’intervallo valido).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Se a è già un ndarray il cui dtype corrisponde a dtype (o dtype è None), restituisce a invariato; altrimenti crea un nuovo array (con la conversione di dtype richiesta, se fornita). Gli iterabili vengono convertiti come in numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Unisce una sequenza di ndarray lungo un axis esistente. Tutti gli array di input devono condividere lo stesso dtype, ndim e forma su ogni asse diverso da axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Per un a 2-D, restituisce un array 1-D contenente la k-esima diagonale. Per un a 1-D, restituisce un array quadrato 2-D con a posizionato sulla k-esima diagonale. k può essere positivo (sopra la diagonale principale) o negativo (sotto).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Alias di zeros; restituisce un array riempito di zeri di shape e dtype. (ulab non lascia il buffer non inizializzato.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Restituisce un array 2-D N x M (quadrato N x N se M è None) con uni sulla k-esima diagonale e zeri altrove.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Interpreta un oggetto conforme al protocollo buffer come un ndarray 1-D di dtype. count è il numero di elementi da leggere (-1 legge tutti gli elementi disponibili); offset salta quel numero di byte all’inizio del buffer.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Restituisce un nuovo array di shape e dtype con ogni elemento impostato a fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Restituisce num campioni spaziati uniformemente sull’intervallo chiuso [start, stop] (o semiaperto se endpoint è False). Quando retstep è True, restituisce una tupla (samples, step). Valori start/stop complessi producono un array complesso (quando il supporto ai numeri complessi è abilitato).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Restituisce num campioni spaziati uniformemente su scala logaritmica: il risultato inizia a base ** start e termina a base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Restituisce una tupla di matrici di coordinate da una sequenza di array di coordinate monodimensionali. Con indexing 'xy' (il valore predefinito) i primi due input sono trattati come coordinate cartesiane e i loro assi di output vengono scambiati; con 'ij' viene usata l’indicizzazione in stile matrice. L’implementazione corrisponde all’equivalente NumPy con copy=True e sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Restituisce un nuovo array di shape e dtype riempito di uni.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Restituisce un nuovo array di shape e dtype riempito di zeri.

Ispezione / stampa¶

numpy.get_printoptions() → dict¶: Restituisce le opzioni correnti di stampa degli array come dict con le chiavi threshold e edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Imposta le opzioni di stampa degli array. threshold è il numero massimo di elementi dell’array stampati per intero; edgeitems è il numero di elementi mostrati a ciascuna estremità di un asse quando l’array viene riassunto.

numpy.ndinfo(array: ndarray) → None¶: Stampa informazioni diagnostiche (forma, strides, dtype, itemsize, …) su array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Restituisce il numero di elementi di a lungo axis; se axis è None, restituisce il numero totale di elementi (il prodotto di ndarray.shape).

Confronto¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Limita i valori di a in modo che a_min <= result <= a_max. Equivale a maximum(a_min, minimum(a, a_max)); il broadcasting segue le stesse regole di minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Esegue x1 == x2 elemento per elemento; restituisce un ndarray booleano (o uno scalare bool se entrambi gli input sono scalari). Fornito per portabilità – l’operatore == sugli array dà lo stesso risultato.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Esegue x1 != x2 elemento per elemento; la controparte booleana di equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Restituisce un array booleano (o uno scalare) che è True dove l’input è finito. Gli input interi sono sempre finiti.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Restituisce un array booleano (o uno scalare) che è True dove l’input è infinito. Gli input interi non sono mai infiniti.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Massimo elemento per elemento di due array / scalari. Gli argomenti vengono sottoposti a broadcast insieme; se i dtype differiscono, l’output viene sottoposto a upcast.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Minimo elemento per elemento di due array / scalari; controparte di maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Restituisce una tupla di ndarray, uno per ciascuna dimensione di a, contenente gli indici degli elementi non nulli di a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Restituisce un ndarray i cui elementi provengono da x dove condition è vero, e da y altrimenti. I tre input vengono sottoposti a broadcast insieme; il dtype di output è l’upcast di x e y.

Riduzioni numeriche¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Verifica se tutti gli elementi lungo axis valutano a True. Con axis=None (il valore predefinito) viene testato l’array appiattito e viene restituito un singolo bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Verifica se almeno un elemento lungo axis valuta a True. Con axis=None viene testato l’array appiattito.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Restituisce l’indice dell’elemento massimo lungo axis. Con axis=None l’array viene appiattito e viene restituito un singolo intero.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Restituisce l’indice dell’elemento minimo lungo axis. Con axis=None l’array viene appiattito e viene restituito un singolo intero.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Restituisce un ndarray di indici interi senza segno le cui voci ordinano a in ordine crescente lungo axis. Il dtype di output è uint16, quindi nessun asse può superare i 65535 elementi. axis=None non è supportato.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Restituisce il prodotto vettoriale di due array 1-D di lunghezza 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Restituisce la n-esima differenza discreta in avanti di a lungo axis. n deve essere compreso in 0..9 (lo stencil di differenziazione è memorizzato in un int8); la lunghezza di axis si riduce di n. Le parole chiave numpy prepend e append non sono implementate.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Restituisce un nuovo array con l’ordine degli elementi invertito lungo axis; con axis=None l’array viene invertito lungo ogni asse.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Restituisce l’elemento massimo lungo axis. Con axis=None (il valore predefinito) l’array appiattito viene ridotto a uno scalare. La parola chiave numpy out non è implementata.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Restituisce l’elemento minimo lungo axis; controparte di max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Restituisce la media aritmetica lungo axis. Con axis=None (il valore predefinito) la media dell’array appiattito viene restituita come float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Restituisce la mediana lungo axis. Con axis=None l’array viene prima appiattito. Il dtype di output è sempre float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Restituisce a con i suoi elementi fatti scorrere (ruotati ciclicamente) di shift posizioni. Con axis=None (il valore predefinito) l’array viene prima appiattito. Gli shift negativi ruotano nella direzione opposta.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Restituisce una copia ordinata di a lungo axis usando l’heap sort. Con axis=None l’array viene prima appiattito. Le parole chiave numpy kind e order non sono implementate.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Restituisce la deviazione standard lungo axis. ddof è il delta dei gradi di libertà – il divisore usato è N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Restituisce la somma lungo axis. Con axis=None il totale dell’array appiattito viene restituito come scalare.

Statistiche¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Conta il numero di occorrenze di ciascun valore nell’array monodimensionale di interi non negativi x. Il dtype di x deve essere uint8 o uint16. Se viene fornito weights, ciascuna voce di x contribuisce con il peso corrispondente anziché con 1 e l’output è di dtype float; altrimenti l’output è di dtype uint16. Se viene fornito minlength, l’array di output ha almeno quel numero di elementi (le voci aggiuntive sono zero).

numpy.trace(m: ndarray) → int | float¶: Restituisce la somma degli elementi diagonali della matrice quadrata m. Il tipo restituito segue il dtype di m (gli array interi producono un int, gli array float un float).

Trasformazione¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Restituisce le porzioni di a selezionate lungo axis dalla condition booleana. Con axis=None viene usato l’array appiattito.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Restituisce una copia di a con le voci agli indices rimosse lungo axis. Con axis=None l’array viene prima appiattito. Gli indici negativi contano dalla fine di axis; indices viene ordinato internamente prima della rimozione.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Restituisce il prodotto scalare di due array. Per due array 1-D è il prodotto interno (uno scalare float). Per gli array 2-D è la moltiplicazione matriciale; le dimensioni interne devono corrispondere. Il risultato è sempre di dtype float.

Approssimazione¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Interpolazione lineare monodimensionale. xp deve essere un array 1-D monotonicamente crescente di valori indipendenti; fp contiene i corrispondenti valori dipendenti; x sono i punti in cui viene valutato l’interpolante. left e right sovrascrivono rispettivamente il valore restituito per x < xp[0] e x > xp[-1] (valori predefiniti: fp[0] e fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integra y usando la regola trapezoidale composita. Se viene fornito x, esso fornisce le posizioni dei campioni corrispondenti a y; altrimenti viene usata la spaziatura dx. y (e x) devono essere 1-D.

Selezione¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Preleva elementi da a agli indices dati lungo axis. Con axis=None viene usato l’array appiattito. mode seleziona il comportamento fuori dai limiti: "raise" (predefinito – solleva ValueError), "wrap" (modulo la lunghezza dell’asse), o "clip" (limita all’intervallo valido; gli indici negativi non sono ammessi). Se viene fornito out, il risultato vi viene scritto.

Bit a bit¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: AND bit a bit elemento per elemento di due array interi; il broadcasting è supportato. Un dtype non intero solleva un’eccezione.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: OR bit a bit elemento per elemento di due array interi.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: XOR bit a bit elemento per elemento di due array interi.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Shift bit a bit elemento per elemento di x1 a sinistra di x2 bit; entrambi gli array devono avere dtype intero.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Shift bit a bit elemento per elemento di x1 a destra di x2 bit; entrambi gli array devono avere dtype intero.

Filtraggio¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Restituisce la convoluzione lineare discreta di due array 1-D. È supportata solo la modalità "full"; la parola chiave numpy mode non è accettata (le altre modalità possono essere ottenute eseguendo lo slicing del risultato completo). La lunghezza dell’output è len(a) + len(v) - 1.

Polinomi¶

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Adatta un polinomio di grado deg ai punti dati (x, y) con il metodo dei minimi quadrati e restituisce i coefficienti del polinomio (grado più alto per primo). Se x è omesso, viene usato range(len(y)). Solleva ValueError se le lunghezze di x e y differiscono.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Valuta il polinomio i cui coefficienti sono p (grado più alto per primo) in x. Se x è uno scalare viene restituito un float, altrimenti un ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Legge un array scritto in precedenza con save dal file (il formato .npy indipendente dalla piattaforma di numpy). L’endianness viene convertita al volo se l’ordine dei byte del file differisce da quello dell’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¶: Legge dati numerici da un file di testo e li restituisce come ndarray. delimiter ha come valore predefinito gli spazi bianchi; comments è il marcatore di commento di riga; max_rows limita il numero di righe di dati lette (-1 per tutte); usecols seleziona le colonne per indice; skiprows salta quel numero di righe iniziali. Se dtype non è float, i valori vengono convertiti per arrotondamento.

numpy.save(file: str, a: ndarray) → None¶: Salva a nel file nel formato .npy indipendente dalla piattaforma di numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Scrive a nel file come testo. delimiter separa i valori all’interno di una riga; header e footer, se forniti, vengono scritti prima/dopo i dati, ciascuno preceduto da comments. I valori vengono scritti in virgola mobile.

Helper per i numeri complessi¶

Queste funzioni sono disponibili solo quando ulab è stato compilato con il supporto ai numeri complessi (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Restituisce la parte reale di val. Per un input di dtype reale, restituisce una copia che preserva il dtype; per un input complesso, restituisce un ndarray float.

numpy.imag(val: ndarray) → ndarray¶: Restituisce la parte immaginaria di val. Per un input di dtype reale, restituisce un array di zeri con lo stesso dtype; per un input complesso, restituisce un ndarray float.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Restituisce il coniugato complesso di val. Gli input a valori reali vengono restituiti invariati.

numpy.sort_complex(a: ndarray) → ndarray¶: Ordina l’array 1-D a prima per parte reale, poi per parte immaginaria. Il risultato è sempre di dtype complesso, anche se a era a valori reali.

Funzioni universali¶

Funzioni matematiche elemento per elemento. Ciascuna accetta uno scalare o un ndarray e restituisce un risultato di forma corrispondente (uno scalare float per input scalare, un ndarray per input array). Quando viene chiamata con un ndarray, il risultato è un nuovo ndarray in virgola mobile; può essere passata una parola chiave out opzionale per scrivere il risultato in un ndarray float pre-allocato della stessa dimensione.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Calcola il coseno inverso (arcocoseno) di ciascun elemento di x; il risultato è in radianti.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Calcola il coseno iperbolico inverso di ciascun elemento di x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Calcola la tangente inversa a due argomenti atan2(y, x) elemento per elemento; supporta il broadcasting tra i due input.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Arrotonda gli elementi dell”ndarray x al numero di decimals indicato; il primo argomento deve essere un ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Calcola il seno inverso (arcoseno) di ciascun elemento di x; il risultato è in radianti.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Calcola il seno iperbolico inverso di ciascun elemento di x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Calcola la tangente inversa (arcotangente) di ciascun elemento di x; il risultato è in radianti.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Calcola la tangente iperbolica inversa di ciascun elemento di x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Calcola il soffitto (il più piccolo intero non inferiore al valore) di ciascun elemento di x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Calcola il coseno di ciascun elemento di x (in radianti).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Calcola il coseno iperbolico di ciascun elemento di x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Converte ciascun elemento di x da radianti a gradi.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Calcola l’esponenziale e**x di ciascun elemento di x; può restituire un ndarray complesso quando viene fornito un input complesso (se il supporto ai numeri complessi è abilitato).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Calcola exp(x) - 1 di ciascun elemento di x con maggiore precisione vicino allo zero.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Calcola il pavimento (il più grande intero non superiore al valore) di ciascun elemento di x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: Calcola il logaritmo naturale di ciascun elemento di x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Calcola il logaritmo in base 10 di ciascun elemento di x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Calcola il logaritmo in base 2 di ciascun elemento di x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Converte ciascun elemento di x da gradi a radianti.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Calcola il seno di ciascun elemento di x (in radianti).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Calcola la funzione sinc normalizzata sin(pi*x) / (pi*x) di ciascun elemento di x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Calcola il seno iperbolico di ciascun elemento di x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Calcola la radice quadrata di ciascun elemento di x; passa dtype=numpy.complex per ottenere risultati complessi per input reali negativi (se il supporto ai numeri complessi è abilitato).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Calcola la tangente di ciascun elemento di x (in radianti).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Calcola la tangente iperbolica di ciascun elemento di x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Restituisce un oggetto chiamabile che applica la funzione Python f elemento per elemento a uno scalare, a un iterabile o a un ndarray; otypes seleziona il dtype di output (predefinito float).

Costanti¶

numpy.e: float¶: Numero di Eulero \(e \approx 2.71828\).

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

numpy.inf: float¶: Infinito positivo in virgola mobile IEEE-754.

numpy.nan: float¶: «Not a number» in virgola mobile IEEE-754.

numpy.bool: int¶: Codice dtype per gli array booleani (memorizzati come uint8).

numpy.uint8: int¶: Codice dtype per gli array di interi senza segno a 8 bit.

numpy.int8: int¶: Codice dtype per gli array di interi con segno a 8 bit.

numpy.uint16: int¶: Codice dtype per gli array di interi senza segno a 16 bit.

numpy.int16: int¶: Codice dtype per gli array di interi con segno a 16 bit.

numpy.float: int¶: Codice dtype per gli array in virgola mobile a 32 bit.

numpy — operazioni su array compatibili con numpy¶