NumPy Cheat Sheet
Ultimo aggiornamento
Creare array
Un array contiene valori di un solo tipo in una griglia con un numero qualsiasi di dimensioni.
| Attività | Codice |
|---|---|
| Importare NumPy | import numpy as np |
| Da una lista | np.array([1, 2, 3]) |
| 2D da liste annidate | np.array([[1, 2, 3], [4, 5, 6]]) |
| Zeri, uni, un valore fisso | np.zeros((2, 3)), np.ones(4), np.full((2, 2), 7) |
| Intervallo con passo (fine esclusa) | np.arange(0, 10, 2) # [0 2 4 6 8] |
| n punti equidistanti (fine inclusa) | np.linspace(0, 1, 5) # [0. 0.25 0.5 0.75 1.] |
| Matrice identità | np.eye(3) |
| Stessa forma di un altro array | np.zeros_like(m), np.ones_like(m) |
| Scegliere il tipo degli elementi | np.array([1, 2, 3], dtype=np.float32) |
| Griglie di coordinate | xx, yy = np.meshgrid(np.arange(3), np.arange(2)) |
Esplorare un array
| Attività | Codice |
|---|---|
| Shape: dimensione di ogni asse | m.shape # (3, 4) |
| Numero di dimensioni | m.ndim # 2 |
| Numero di elementi | m.size # 12 |
| Tipo degli elementi | m.dtype # int64 |
| Convertire il tipo | m.astype(np.float64) |
| Lunghezza della prima dimensione | len(m) # 3 |
| Tornare a una lista Python | m.tolist() |
| Stampare meno decimali | np.set_printoptions(precision=3, suppress=True) |
Indicizzare e fare slicing
Gli slice sono view: condividono la memoria con l'array originale. Maschere e liste di indici restituiscono copie.
| Attività | Codice |
|---|---|
| Primo e ultimo elemento | a[0], a[-1] |
| Slice start:stop (stop escluso) | a[1:4] # [20 30 40] |
| Un elemento ogni due, al contrario | a[::2], a[::-1] |
| Un elemento di un array 2D | m[1, 2] # 6 |
| Una riga, una colonna | m[0], m[:, 1] |
| Un blocco di righe e colonne | m[:2, 1:3] |
| Elementi che soddisfano una condizione | a[a > 25] # [30 40 50] |
| Combinare condizioni | a[(a > 15) & (a < 45)] |
| Scegliere con una lista di posizioni | a[[0, 2, 4]] |
| Posizioni che soddisfano la condizione | np.flatnonzero(a > 25) # [2 3 4] |
| Scegliere elemento per elemento | np.where(a > 25, a, 0) |
| Copiare prima di modificare uno slice | part = a[1:3].copy() |
| Assegnare valori con una maschera | a[a > 40] = 0 |
Calcoli e broadcasting
Gli operatori lavorano elemento per elemento. Il broadcasting estende uno scalare, una riga o una colonna per adattarli alla forma dell'altro array.
| Attività | Codice |
|---|---|
| Aritmetica elemento per elemento | x + y, x - y, x * y, x / y, x ** 2 |
| Con uno scalare | x * 10 |
| Radice quadrata, esponenziale, logaritmo | np.sqrt(x), np.exp(x), np.log(x) |
| Valore assoluto, arrotondamento | np.abs(x - 5), np.round(x / 3, 2) |
| Limitare i valori a un intervallo | np.clip(x, 2, 8) |
| Massimo elemento per elemento | np.maximum(x, 3) |
| Prodotto scalare | x @ y # 37.0 |
| Centrare ogni colonna (broadcast di una riga) | m - m.mean(axis=0) |
| Scalare ogni riga (broadcast di una colonna) | m / m.sum(axis=1, keepdims=True) |
| Confrontare float in modo sicuro | np.isclose(0.1 + 0.2, 0.3) # True, np.allclose(x, y) |
| Trigonometria e pi greco | np.sin(np.pi / 2) # 1.0 |
Aggregare lungo un asse
axis=0 scorre lungo le righe e dà un risultato per colonna. axis=1 scorre lungo le colonne e dà un risultato per riga.
| Attività | Codice |
|---|---|
| Somma di tutti gli elementi | m.sum() # 21 |
| Un risultato per colonna | m.sum(axis=0) # [5 7 9] |
| Un risultato per riga | m.sum(axis=1) # [ 6 15] |
| Media e deviazione standard | m.mean(), m.std(), m.mean(axis=0) |
| Minimo, massimo | m.min(), m.max(axis=1) |
| Posizione del massimo | m.argmax(), m.argmax(axis=1) |
| Mediana e percentili | np.median(m), np.percentile(m, [25, 50, 75]) |
| Somma cumulativa | np.cumsum(m, axis=1) |
| Prodotto di tutti gli elementi | m.prod() # 720 |
| Any, all, conteggio | (m > 4).any(), (m > 0).all(), np.count_nonzero(m > 2) |
Cambiare forma e combinare
Un reshape mantiene gli elementi e cambia la forma, quindi la dimensione totale deve restare la stessa.
| Attività | Codice |
|---|---|
| Nuova forma | a.reshape(2, 3) |
| Lasciare che NumPy calcoli una dimensione | a.reshape(3, -1), a.reshape(-1, 1) |
| Appiattire in 1D | m.ravel(), m.flatten() |
| Trasposta | m.T |
| Aggiungere una dimensione | a[:, np.newaxis], np.expand_dims(a, axis=0) |
| Togliere le dimensioni di lunghezza 1 | np.squeeze(np.ones((1, 3, 1))) |
| Unire lungo un asse esistente | np.concatenate([a, a]) |
| Impilare righe o colonne | np.vstack([m, m]), np.hstack([m, m]) |
| Array 1D come colonne | np.column_stack([a, a ** 2]) |
| Impilare lungo un nuovo asse | np.stack([a, a], axis=0) # shape (2, 6) |
| Dividere in parti | np.split(a, 3), np.array_split(a, 4) |
| Ripetere o affiancare | np.repeat([1, 2], 2) # [1 1 2 2], np.tile([1, 2], 2) # [1 2 1 2] |
Ordinare, cercare e valori unici
| Attività | Codice |
|---|---|
| Copia ordinata | np.sort(a) |
| Prima i più grandi | np.sort(a)[::-1] |
| Posizioni che ordinerebbero l'array | np.argsort(a) |
| I tre valori più grandi | np.sort(a)[-3:] |
| Valori unici e loro conteggi | values, counts = np.unique(a, return_counts=True) |
Nomi di NumPy 2 (unique_values può non essere ordinato) | np.unique_values(a), np.unique_counts(a) |
| Ogni elemento è in una lista? | np.isin(a, [1, 9]) |
| Posizione di inserimento in un array ordinato | np.searchsorted([1, 3, 5, 7], 4) # 2 |
| Operazioni insiemistiche | np.intersect1d(a, [1, 2, 10]), np.union1d(a, [10]), np.setdiff1d(a, [1]) |
| Ordinare le righe per una colonna | m[m[:, 1].argsort()] |
Numeri casuali
Crea un solo Generator con seed e genera tutto da lì, così i risultati si ripetono a ogni esecuzione.
| Attività | Codice |
|---|---|
| Generatore con seed | rng = np.random.default_rng(42) |
| Float in [0, 1) | rng.random(3) |
| Interi, estremo superiore escluso | rng.integers(1, 7, size=10) |
| Distribuzione normale | rng.normal(loc=0, scale=1, size=(2, 3)) |
| Float uniformi in un intervallo | rng.uniform(5, 10, size=4) |
| Estrarre da una lista | rng.choice(["a", "b", "c"], size=5) |
| Estrarre senza ripetizioni | rng.choice(10, size=3, replace=False) |
| Estrarre con pesi | rng.choice(["H", "T"], size=10, p=[0.7, 0.3]) |
| Copia mescolata, mescolare sul posto | rng.permutation(a), rng.shuffle(a) |
| Conteggi binomiali e di Poisson | rng.binomial(10, 0.5, size=5), rng.poisson(3, size=5) |
Algebra lineare
| Attività | Codice |
|---|---|
| Prodotto tra matrici | A @ A |
| Risolvere Ax = b | np.linalg.solve(A, b) # [0.8 1.4] |
| Inversa e determinante | np.linalg.inv(A), np.linalg.det(A) |
| Lunghezza di un vettore | np.linalg.norm(b) |
| Autovalori e autovettori | values, vectors = np.linalg.eig(A) |
| Adattare una retta | slope, intercept = np.polyfit(x, y, 1) |
| Prodotto esterno | np.outer([1, 2], [3, 4]) |
| Diagonale e traccia | np.diag(A), np.trace(A) |
Valori mancanti e speciali
np.nan indica un float mancante. Qualsiasi operazione con esso dà nan, quindi usa le funzioni nan o una maschera.
| Attività | Codice |
|---|---|
| Valore mancante | np.nan |
| Trovare i valori mancanti | np.isnan(v), np.isnan(v).sum() |
| Eliminare i valori mancanti | v[~np.isnan(v)] |
| Sostituire valori mancanti e infiniti | np.nan_to_num(v, nan=0.0, posinf=0.0) |
| Controlli su infiniti e finiti | np.inf, np.isfinite(v) |
| Statistiche che ignorano NaN | np.nanmean(v[:3]) # 2.0, np.nanmax(v) |
Salvare e caricare
| Attività | Codice |
|---|---|
| Un array, file binario | np.save("data.npy", m), m = np.load("data.npy") |
| Più array in un file | np.savez("data.npz", x=x, y=y), np.load("data.npz")["x"] |
| Scrivere testo CSV | np.savetxt("data.csv", m, delimiter=",", fmt="%d") |
| Leggere testo CSV | np.loadtxt("data.csv", delimiter=",") |
NumPy 2: vecchi nomi e cosa scrivere ora
NumPy 2 ha rimosso molti alias, quindi il codice copiato da tutorial più vecchi può fallire con un AttributeError.
| Attività | NumPy 2 | Vecchia forma |
|---|---|---|
| Valore mancante | np.nan | np.NaN |
| Infinito | np.inf | np.Inf |
| Tipo float a 64 bit | np.float64 | np.float_ |
| Area sotto una curva | np.trapezoid(y, x) | np.trapz(y, x) |
| Ogni elemento è in un altro array? | np.isin(a, b) | np.in1d(a, b) |
| Impilare righe | np.vstack([a, a]) | np.row_stack([a, a]) |
| Prodotto | np.prod(a) | np.product(a) |
| Numeri casuali | rng = np.random.default_rng(0)
rng.random(3) | np.random.seed(0)
np.random.rand(3) |
Le chiamate NumPy su cui si basa il codice di data science, raggruppate per attività: creare array, esplorarli, indicizzare e fare slicing, fare calcoli elemento per elemento, aggregare lungo un asse, cambiare forma e combinare, ordinare e cercare, generare numeri casuali e risolvere problemi di algebra lineare. Ogni riga è un breve snippet da incollare, con una riga che spiega cosa fa.
Tutto è scritto per NumPy 2, la versione che usa Coddy, e l'ultima tabella elenca i nomi rimossi in NumPy 2, accanto a cosa scrivere al loro posto. La maggior parte degli esempi usa a = np.array([3, 1, 4, 1, 5, 9, 2, 6]) e m = np.arange(12).reshape(3, 4). Sei alle prime armi con Python? Parti dal Python cheat sheet e dal playground Python, e tieni a portata di mano anche i cheat sheet di pandas, Matplotlib e scikit-learn.
FAQ sul cheat sheet di NumPy
Questo cheat sheet di NumPy è gratuito?
Sì. Questo cheat sheet di NumPy è completamente gratuito e non serve registrarsi. Salvalo nei preferiti o stampalo in PDF dal browser, e tornaci ogni volta che ti serve la chiamata esatta per un reshape, una somma lungo un asse o un'estrazione casuale.
Quale versione di NumPy copre questo cheat sheet?
NumPy 2. Ogni snippet funziona su NumPy 2.4, la versione che usa Coddy. NumPy 2 ha rimosso alias come
np.NaN, np.float_, np.trapz e np.in1d, quindi l'ultima tabella mostra ognuno accanto al nome attuale.Cosa significa axis=0 in NumPy?
L'asse è la dimensione che viene compressa. In un array 2D,
axis=0 scorre lungo le righe, quindi m.sum(axis=0) restituisce un totale per colonna. axis=1 scorre lungo le colonne e restituisce un totale per riga. Senza asse, la funzione usa tutti gli elementi.Qual è la differenza tra una view e una copia?
Uno slice come
a[1:3] è una view: condivide la memoria con a, quindi modificare lo slice modifica a. Le maschere booleane e le liste di indici come a[a > 2] o a[[0, 2]] restituiscono copie. Chiama .copy() quando ti serve un array indipendente.Perché usare un array NumPy invece di una lista Python?
Gli array memorizzano un solo tipo in un unico blocco di memoria, quindi i calcoli su un intero array girano in codice compilato e spesso sono molte volte più veloci di un ciclo Python.
a * 2 raddoppia ogni elemento, mentre [1, 2] * 2 ripete la lista. pandas e scikit-learn sono costruiti sugli array NumPy.Meglio np.random.seed o default_rng?
Usa
rng = np.random.default_rng(seed) e chiama i metodi su rng, come rng.normal() o rng.integers(). È l'API consigliata, con flussi casuali migliori e nessuno stato globale nascosto. np.random.seed e np.random.rand funzionano ancora, ma sono l'interfaccia legacy.Posso eseguire codice NumPy online?
Sì. Il playground Matplotlib gratuito esegue Python con NumPy, pandas, Matplotlib e scikit-learn nel browser, così puoi incollare qualsiasi snippet di questo cheat sheet ed eseguirlo senza installare nulla. Il corso di Machine Learning di Coddy insegna NumPy passo dopo passo, lavorando con dati reali.
Risorse correlate
Altre cheat sheet
