Pour définir un tableau à une dimension :
>>> from numpy import array >>> array((1,2,3,4,5))
et pour un tableau deux dimensions :
>>> array(([0,1],[1,3]))
On procède de la même manière...
>>> matrix(([0,1],[1,3]))
matrix([[0, 1],
[1, 3]])
On peut voir qu'il force la 2D :
>>> matrix((1,2,3,4,5)) matrix([ [1, 2, 3, 4, 5] ])
Les constructeurs des classes array et matrix acceptent certains objets en argument, pour construire des tableaux/matrices à partir d'eux.
Ces objets peuvent être des listes, des tuples,
>>> L=[1,2,3] >>> dd=array(L) >>> dd array([1, 2, 3])
ou encore d'autres array/matrix :
>>> aa = array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8]])
>>> dd=array(aa)
Plus précisément, le constructeur est
array(object, dtype = float, copy = 1, order = None, subok = 0, ndmin = 0)
où
>>> aa=array([ [1,2,3] ])
>>> bb[0,1]=2 >>> bb array([ [1, 2, 3] ]) >>> aa array([ [1, 2, 3] ])
On s'aperçoit que la modification de bb entraîne celle de aa. Alors que...
>>> cc=array(aa, copy = 1) >>> cc[0,1]=222 >>> cc array([ [1, 222, 3] ]) >>> aa array([ [1, 2, 3] ])
>>> L=[1,2,3]
>>> dd array([ [1, 2, 3] ])
A comparer avec ce qui précède.
On peut utiliser arange pour créer un vecteur :
>>> from numpy import arange >>> arange(10) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Cette fonction est polymorphe : arange(a,b) crée un vecteur de a à b, avec un pas de 1 :
>>> arange(4,8) array([4, 5, 6, 7]) >>> arange(10.5,12.4) array([ 10.5, 11.5])
On peut changer le pas en ajoutant un troisième argument :
>>> arange(10.5, 12.4, 0.3) array([ 10.5, 10.8, 11.1, 11.4, 11.7, 12. , 12.3])
Enfin, on peut à chaque fois préciser le type voulu :
>>> arange(4,8,dtype=float) array([ 4., 5., 6., 7.])
Avec linspace, on fournit le point de départ et d'arrivée du vecteur, ainsi que le nombre de points voulu...
>>> from numpy import linspace >>> linspace(5, 10, num = 5) array([ 5. , 6.25, 7.5 , 8.75, 10. ])
Et on obtient un vecteur, ayant la taille voulue, aux valeurs interpolées linéairement.
On peut souhaiter ne pas considérer le point d'arrivée :
>>> linspace(5, 10, num = 4, endpoint = False) array([ 5. , 6.25, 7.5 , 8.75])
Auquel cas, le pas n'est pas toujours évident à voir, aussi on peut exiger qu'il fasse partie du retour de la fonction :
>>> linspace(5, 10, num = 4, endpoint = False, retstep = True) (array([ 5. , 6.25, 7.5 , 8.75]), 1.25)
La fonction logspace fonctionne un peu comme linspace, mais en échelle log.
>>> from numpy import logspace
>>> logspace(0, 1, num = 10)
array([ 1. , 1.29154967, 1.66810054, 2.15443469,
2.7825594 , 3.59381366, 4.64158883, 5.9948425 ,
7.74263683, 10. ])
Dans ce qui précède, on calcule $10^x$, pour $x$ prenant 10 valeurs équiréparties dans [0,1], ce qui correspond donc a :
>>> array([10**k for k in linspace(0,1,num = 10)]) array([1.0, 1.2915496650148839, 1.6681005372000588, 2.1544346900318838, 2.7825594022071245, 3.5938136638046276, 4.6415888336127784, 5.9948425031894086, 7.7426368268112693, 10.0])
On peut, comme pour linspace, décider de ne pas prendre la valeur d'arrivée.
>>> logspace(1, 2, num = 10)
array([ 10. , 12.91549665, 16.68100537, 21.5443469 ,
27.82559402, 35.93813664, 46.41588834, 59.94842503,
77.42636827, 100. ])
>>> logspace(1,10,num=10)
array([ 1.00000000e+01, 1.00000000e+02, 1.00000000e+03,
1.00000000e+04, 1.00000000e+05, 1.00000000e+06,
1.00000000e+07, 1.00000000e+08, 1.00000000e+09,
1.00000000e+10])
La base peut être changée :
>>> logspace(1, 10, num=10, base = 2)
array([ 2., 4., 8., 16., 32., 64., 128., 256.,
512., 1024.])
Pour finir, et pour se convaincre que l'on est bien en échelle log, on peut tracer le résultat :
>>> from pylab import plot, show >>> plot(linspace(0,100,num = 100),logspace(0,2,num = 100)) [<matplotlib.lines.Line2D instance at 0x8d1b18c>] >>> show()
On peut créer un tableau constitué uniquement que de uns :
>>> from numpy import * >>> x = ones( (3,4) ) >>> ones( (2,3,4), dtype=int16 )
de zéros :
>>> x = zeros( (3,4), dtype = float)
ou de rien du tout :
>>> x = empty( (3,4), dtype = float )