Pour la creation et manipulation de matrices et vecteurs, nous pouvons utiliser les modules scipy ou numpy.

In [1]:
import scipy as sp
# Ou import numpy as np

Pour créer des vecteurs et matrices, il suffit de créer des instances de array.

Soit à partir de listes (pour les vecteurs) ou listes de listes (matrices).

In [2]:
x = sp.array([1,2,3])
print x

[1 2 3]
In [3]:
M = sp.array([[1,2,3],[4,5,6]])
print M

[[1 2 3]
 [4 5 6]]

Soit en utilisant des fonctions (comme nous l'avons fait avec range pour des listes).

In [4]:
x = sp.ones(5)
M = sp.ones((3,2))
print x
print M

[ 1.  1.  1.  1.  1.]
[[ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]]
In [5]:
M = sp.identity(3)
N = sp.diag([1,2,3])
print M
print N

[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]
[[1 0 0]
 [0 2 0]
 [0 0 3]]
In [6]:
x = sp.arange(10)
y = sp.linspace(0,1,11)
print x
print y

[0 1 2 3 4 5 6 7 8 9]
[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1. ]

Toutes les opérations arithmétiques effectuées élément par élément, incluant la multiplication!

In [7]:
print x + x
print 10 * x

[ 0  2  4  6  8 10 12 14 16 18]
[ 0 10 20 30 40 50 60 70 80 90]

La fonction dot est utilisée pour la multiplication vectorielle (entre n'importe quel pair de array peu import s'ils sont des matrices ou vecteurs).

In [8]:
x = sp.array([1,2,3])
N = sp.diag([1,2,3])
print sp.dot(N, x)

[1 4 9]
In [9]:
print sp.dot(N, N)

[[1 0 0]
 [0 4 0]
 [0 0 9]]

L'attribut .T permet d'obtenir la transposée.

Remarque (avancée): En fait .T est une méthode qui est appelée avec une syntaxe particulière sans parenthèses.

In [10]:
M = sp.array([[1,2,3],[4,5,6]])
print M
print M.T

[[1 2 3]
 [4 5 6]]
[[1 4]
 [2 5]
 [3 6]]

Voici quelques méthodes utiles pour les arrays.

In [11]:
print M.max()

6
In [12]:
print M.sum()

21
In [13]:
print sp.size(x)
print M.shape

3
(2, 3)

Les comparateurs >, ==, < etc sont aussi appliqués élément par élément.

In [14]:
x = sp.array([1,2,3,4])
print x > 2.5

[False False  True  True]

Cela devient très utile lorsqu'on veut sélectionner des entrées d'un array avec la syntaxe A[B].

In [15]:
A = sp.array([[4, 1, 5], [10, 9, 8], [7, 7, 5]])
print A
B = (A > 3)
print B
print A[B]

[[ 4  1  5]
 [10  9  8]
 [ 7  7  5]]
[[ True False  True]
 [ True  True  True]
 [ True  True  True]]
[ 4  5 10  9  8  7  7  5]

Ou si on veut modifier certains entrées seulement. Voici un exemple où on ajoute 1 à tous les entrée plus grand que 2.5.

In [16]:
x = sp.array([1,2,3,4])
print x
print x > 2.5
print x[x > 2.5]
x[x > 2.5] += 1
print x

[1 2 3 4]
[False False  True  True]
[3 4]
[1 2 4 5]

La méthode .where permet d'obtenir les coordonnée (plutôt que les entrées que donne les comparateurs).

In [17]:
M = sp.rand(3,3)
print M
sp.where(M > 0.5)

[[ 0.96398971  0.30971898  0.79790582]
 [ 0.68565304  0.03439127  0.54248998]
 [ 0.62063371  0.48655713  0.12617676]]
Out[17]:
(array([0, 0, 1, 1, 2]), array([0, 2, 0, 2, 0]))
In [18]:
indices = sp.where(x > 2.5)[0]
print indices

[2 3]

Tracée de courbes « scientifiques » avec pylab

In [19]:
import pylab as pl

Pour voir le résultat des tracées dans cette page, lancer ipython ou jupyter avec --pylab=inline. Dans les nouvelles version, il est aussi possible de lancer d'ici:

In [20]:
%matplotlib inline

Tracée 1D

Pour tracer une sinusoide:

In [21]:
x = pl.linspace(-5,5,101) # coordonnées de -5 à 5 avec 101 valeurs
y = pl.sin(x)
pl.plot(x,y) # Tracé de la courbe !
Out[21]:
[<matplotlib.lines.Line2D at 0x7fdbe0a1fa10>]

Pour tracer plusieurs courbes, on peut les mettre les unes à la suite des autres, par exemple :

In [23]:
pl.plot(x, y, "r-", x, pl.cos(x), "g.")
Out[23]:
[<matplotlib.lines.Line2D at 0x7fdbe0974dd0>,
 <matplotlib.lines.Line2D at 0x7fdbe0974fd0>]

Pour cela on utilise imshow(z) ou pcolor(x,y,z).

In [24]:
z = pl.identity(10)
pl.imshow(z)   # Affiche les entrées de la matrice z en 2D
Out[24]:
<matplotlib.image.AxesImage at 0x7fdbe0793390>
In [25]:
x = pl.linspace(-5,5,201)
y = pl.linspace(-7,7,201)[:, pl.newaxis] 
   # newaxis indique que ce vecteur est selon la 2ème dimension
z = pl.sin(x**2 + y**2)
pl.imshow(z) # Affiche l'image en 2D

pl.imshow(z, extent=(x.min(), x.max(), y.min(), y.max()))
   # On précise les coordonnées des axes
Out[25]:
<matplotlib.image.AxesImage at 0x7fdbe092c1d0>
In [26]:
import pylab as pl

pl.figure(1, figsize=(6,6))
ax = pl.axes([0.1, 0.1, 0.8, 0.8])

labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
fracs = [15,30,45, 10]
explode = (0, 0.05, 0, 0)
pl.pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%',
shadow=True)
pl.title('Raining Hogs and Dogs', bbox={'facecolor':'0.8', 'pad':5})
pl.show()
In [ ]: