Python versione Bignami - Array numpy

Import

Import di numpy: from numpy import *

Creazione

Costruzione di un vettore: a = array([0, 1, 2, 3])
Costruzione di una matrice 3x3: a = array([0, 1, 2], [3, 4, 5], [6, 7, 8])
Vettore dei numeri da 0 a 10: a = arange(10)
Vettore dei numeri da 10 a 100 a passi di 0.5: a = arange(10, 100, 0.5)
Vettore di 100 numeri da 0 a pi greco: a = linspace(0, pi, 100)
Matrice 3x4 di valori 0: a = zeros( (3, 4) )
Matrice 3x4 di valori 1: a = ones( (3, 4) )
Matrice di valori 0 con valori specifici sulla diagonale: a = diag([1, 2, 3, 4, 5])
Matrice di valori 0 con valori specifici sulla terza diagonale: a = diag([1, 2, 3, 4, 5], 3)

Costruzione data una funzione:

def f(x, y):
    return x ** 2 + y ** 2
a = fromfunction(f, (10, 10))

Operazioni

Rango della matrice: a.ndim
Dimensioni della matrice: a.shape (restituisce a.ndim valori)
Numero di elementi nella matrice: a.size (equivale al prodotto di tutti i risultati di a.shape)
Tipo degli elementi nella matrice: a.dtype
Dimensione in byte di un elemento della matrice: a.itemsize
Somma membro a membro: x = a + b, a += b
Differenza membro a membro: x = a - b, a -= b
Prodotto membro a membro: x = a * b, a *= b
Prodotto matriciale: x = dot(a, b)
Divisione membro a membro: x = a / b, a /= b
Tante altre operazioni

Indicizzazione

I vettori si indicizzano come le liste Python:

>>> a = arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a[1]
1
>>> a[1] = 10
>>> a
array([ 0, 10,  2,  3,  4,  5,  6,  7,  8,  9])
>>> a[2:6]
array([2, 3, 4, 5])
>>> a[2:8:2]
array([2, 4, 6])
>>> a[:2:-1]
array([9, 8, 7, 6, 5, 4, 3])

Le matrici supportano indici come le liste Python per ogni dimensione:

>>> def f(x,y):
...         return 10*x+y
...
>>> b = fromfunction(f,(5,4))
>>> b
array([[ 0,  1,  2,  3],
             [10, 11, 12, 13],
             [20, 21, 22, 23],
             [30, 31, 32, 33],
             [40, 41, 42, 43]])
>>> b[2,3]
23
>>> b[:,1]                   # la seconda colonna di b
array([ 1, 11, 21, 31, 41])
>>> b[1:3,:]                 # la seconda e terza riga di b
array([[10, 11, 12, 13],
             [20, 21, 22, 23]]) 
>>> b[1:4,1:3]               # Sottomatrice
array([[11, 12],
             [21, 22],
             [31, 32]])

Omettendo indici si intende la riga / colonna / sottomatrice intera:

>>> b[-1]                    # l'ultima riga. Equivalente a b[-1,:]
array([40, 41, 42, 43])

Iterazione

Le matrici possono essere iterate, una dimensione alla volta:

>>> def f(x,y):
...         return 10*x+y
...
>>> b = fromfunction(f,(5,4))
>>> b
array([[ 0,  1,  2,  3],
             [10, 11, 12, 13],
             [20, 21, 22, 23],
             [30, 31, 32, 33],
             [40, 41, 42, 43]])
>>> for row in b:
...   print row
...   for el in row:
...     print " ", el
...
[0 1 2 3]
    0
    1
    2
    3
[10 11 12 13]
    10
    11
    12
    13
[20 21 22 23]
    20
    21
    22
    23
[30 31 32 33]
    30
    31
    32
    33
[40 41 42 43]
    40
    41
    42
    43

O tutti gli elementi in fila usando il metodo flat:

>>> for element in b.flat:
...    print element,
...
0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43

Plot di un vettore

    from pylab import *
    a = linspace(0, 3*pi, 100)
    plot(a, sin(a), 'b-', a, cos(a), 'r-')
    show()

Salvare su disco e caricare da disco

    # Salva in formato binario.
    # Viene salvata la sequenza grezza di numeri, senza informazioni sul tipo
    # di dato o sulle dimensioni
    a = fromfunction(lambda x, y: x**2 + y**2, (5, 5))
    a.tofile("/tmp/matrice")

    # Carica da file.  Bisogna specificare il tipo di dato (se non è float) e
    # le dimensioni (se non è un vettore)
    b = fromfile("/tmp/matrice", int)
    b.shape = (5, 5)

    # Salva in formato testo
    a.tofile("/tmp/matrice.txt", sep=",", format="%d")

    # Carica da file in formato testo
    b = fromfile("/tmp/matrice.txt", sep=",")
    b.shape = (5, 5)

Gestione degli errori di calcolo

Normalmente numpy ignora gli errori durante il calcolo. Questo comportamento si può cambiare usando numpy.seterr:

    numpy.seterr(divide=None, over=None, under=None, invalid=None)

Ognuno dei parametri può essere settato a:

"ignore": ignora l'errore (default)
"warn": stampa un warning in output e ignora l'errore
"raise": lancia un'eccezione
"call": chiama la funzione impostata con seterrcall

I parametri, tutti opzionali, rappresentano:

divide: divisione per 0
over: overflow
under: underflow
invalid: operazione non valida (ad esempio, la radice di numeri negativi)

seterr restituisce un dizionario con le impostazioni che erano attive prima che fosse chiamata.

Per settare la callback si usa seterrcall:

numpy.seterrcall(funzione)

La funzione callback prende due parametri, una stringa con la descrizione dell'errore e un numero i cui bit rappresentano il tipo di errore.

Esempio:

# Funzione callback def handler(msg, status): print msg if status & 1 != 0: print "Errore di divisione" if status & 2 != 0: print "Overflow" if status & 4 != 0: print "Underflow" if status & 8 != 0: print "Operazione non valida"

# Imposta la callback
numpy.seterrcall(handler)

# Configura la gestione degli errori di calcolo
old = numpy.seterr(divide="raise", over="call", under="warn", invalid="raise")

# Stampa la vecchia configurazione
print "Old settings:"
for type, val in old.iteritems():
    print "%s: %s" % (type, val)