Compréhension approfondie du didacticiel concis NumPy --- Array 2

Tableau NumPy (2. Opérations sur les tableaux)

Opérations de base

Les opérations arithmétiques sur les tableaux sont effectuées élément par élément. Les opérations sur les tableaux créent un nouveau tableau contenant les résultats de l'opération.

>>> a= np.array([20,30,40,50]) 
>>> b= np.arange( 4) 
>>> b 
array([0, 1, 2, 3]) 
>>> c= a-b 
>>> c 
array([20, 29, 38, 47]) 
>>> b**2 
array([0, 1, 4, 9]) 
>>> 10*np.sin(a) 
array([ 9.12945251,-9.88031624, 7.4511316, -2.62374854]) 
>>> a<35 
array([True, True, False, False], dtype=bool)

Contrairement à d'autres langages matriciels, les opérateurs de multiplication dans NumPy* sont calculés élément par élément. La multiplication matricielle peut être implémentée à l'aide de la fonction point ou en créant un. objet matriciel. (Sera introduit dans les chapitres suivants)

>>> A= np.array([[1,1], 
...[0,1]]) 
>>> B= np.array([[2,0], 
...[3,4]]) 
>>> A*B # 逐个元素相乘 
array([[2, 0], 
  　　 [0, 4]]) 
>>> np.dot(A,B) # 矩阵相乘 
array([[5, 4], 
  　　 [3, 4]])

Certains opérateurs tels que = et *= sont utilisés pour modifier des tableaux existants sans en créer un nouveau. tableau.

>>> a= np.ones((2,3), dtype=int) 
>>> b= np.random.random((2,3)) 
>>> a*= 3 
>>> a 
array([[3, 3, 3], 
  　　 [3, 3, 3]]) 
>>> b+= a 
>>> b 
array([[ 3.69092703, 3.8324276, 3.0114541], 
  　　　 [ 3.18679111, 3.3039349, 3.37600289]]) 
>>> a+= b # b转换为整数类型 
>>> a 
array([[6, 6, 6], 
      [6, 6, 6]])

Lorsque le tableau stocke des éléments de différents types, le tableau utilisera le type de données qui occupe le plus de bits comme son propre type de données, c'est-à-dire préférant un type de données plus précis (ce comportement est appelé upcast).

>>> a= np.ones(3, dtype=np.int32) 
>>> b= np.linspace(0,np.pi,3) 
>>> b.dtype.name 
'float64' 
>>> c= a+b 
>>> c 
array([ 1., 2.57079633, 4.14159265]) 
>>> c.dtype.name 
'float64' 
>>> d= exp(c*1j) 
>>> d 
array([ 0.54030231+0.84147098j,-0.84147098+0.54030231j, 
  　　　 -0.54030231-0.84147098j]) 
>>> d.dtype.name 
'complex128'

De nombreuses opérations non liées aux tableaux, telles que le calcul de la somme de tous les éléments d'un tableau, sont implémentées en tant que méthodes de la classe ndarray lors de l'utilisation. eux, vous devez utiliser l'instance de classe ndarray pour appeler ces méthodes.

>>> a= np.random.random((2,3)) 
>>> a 
array([[ 0.65806048, 0.58216761, 0.59986935], 
      [ 0.6004008, 0.41965453, 0.71487337]]) 
>>> a.sum() 
　 3.5750261436902333 
>>> a.min() 
   0.41965453489104032 
>>> a.max() 
   0.71487337095581649

Ces opérations traitent les tableaux comme des listes linéaires unidimensionnelles. Cependant, vous pouvez effectuer les opérations correspondantes sur l'axe spécifié en spécifiant le paramètre d'axe (c'est-à-dire la ligne du tableau) :

>>> b= np.arange(12).reshape(3,4) 
>>> b 
array([[ 0, 1, 2, 3], 
      [ 4, 5, 6, 7], 
      [ 8, 9, 10, 11]]) 
>>> b.sum(axis=0) # 计算每一列的和，注意理解轴的含义，参考数组的第一篇文章 
array([12, 15, 18, 21]) 
>>> b.min(axis=1) # 获取每一行的最小值 
array([0, 4, 8]) 
>>> b.cumsum(axis=1) # 计算每一行的累积和 
array([[ 0, 1, 3, 6], 
      [ 4, 9, 15, 22], 
      [ 8, 17, 27, 38]])

Indexation, découpage et itération

Comme les listes et autres séquences Python, les tableaux unidimensionnels peuvent être indexés, découpés et itérés.

>>> a= np.arange(10)**3 #记住，操作符是对数组中逐元素处理的！ 
>>> a 
array([0, 1, 8, 27, 64, 125, 216, 343, 512, 729]) 
>>> a[2] 
8 
>>> a[2:5] 
array([ 8, 27, 64]) 
>>> a[:6:2]= -1000 # 等同于a[0:6:2]= -1000，从开始到第6个位置，每隔一个元素将其赋值为-1000 
>>> a 
array([-1000, 1,-1000, 27,-1000, 125, 216, 343, 512, 729]) 
>>> a[: :-1] # 反转a 
array([ 729, 512, 343, 216, 125,-1000, 27,-1000, 1,-1000]) 
>>>for i in a: 
...  print i**(1/3.), 
... 
nan 1.0 nan 3.0 nan 5.0 6.0 7.0 8.0 9.0

Les tableaux multidimensionnels peuvent avoir un index par axe. Les indices sont donnés sous forme de tuple séparé par des virgules.

>>>def f(x,y): 
...  return 10*x+y 
... 
>>> b= np.fromfunction(f,(5,4),dtype=int) #fromfunction是一个函数，下篇文章介绍。 
>>> 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[0:5, 1] # 每行的第二个元素 
array([ 1, 11, 21, 31, 41]) 
>>> b[: ,1] # 与前面的效果相同 
array([ 1, 11, 21, 31, 41]) 
>>> b[1:3,: ] # 每列的第二和第三个元素 
array([[10, 11, 12, 13], 
      [20, 21, 22, 23]])

Lorsque le nombre d'index fournis est inférieur au nombre d'axes, les valeurs données sont copiées par ordre de rang, et les valeurs manquantes index est La valeur par défaut est la tranche entière :

>>> b[-1] # 最后一行，等同于b[-1,:]，-1是第一个轴，而缺失的认为是：，相当于整个切片。 
array([40, 41, 42, 43])

L'expression entre parenthèses dans b[i] est traitée comme i et une série de :, to représentent l’axe de repos. NumPy vous permet également d'utiliser des "points" comme b[i,...]. Les points

(…) représentent le nombre de points-virgules nécessaires pour produire un tuple d'index complet. Si x est un tableau de rang 5 (c'est-à-dire qu'il comporte 5 axes), alors :

• x[1,2,…] est équivalent à x[1,2,:,: ,:],

• x[…,3] est équivalent à x[:,:,:,:,3]

• x [ 4,…,5,:] est équivalent à x[4,:,:,5,:]　

>>> c= array( [ [[ 0, 1, 2], #三维数组（两个2维数组叠加而成） 
...[ 10, 12, 13]], 
... 
...[[100,101,102], 
...[110,112,113]]] ) 
>>> c.shape 
 (2, 2, 3) 
>>> c[1,...] #等同于c[1,:,:]或c[1] 
array([[100, 101, 102], 
      [110, 112, 113]]) 
>>> c[...,2] #等同于c[:,:,2] 
array([[ 2, 13], 
      [102, 113]])

tableau multidimensionnel Le parcours est basé sur le premier axe :

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

Si vous souhaitez traiter chaque élément du tableau, vous pouvez utiliser l'attribut plat , cet attribut est un itérateur d'élément de tableau :

>>>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

Opération de forme

Changer la forme d'un tableau

La forme d'un tableau dépend du nombre d'éléments sur chaque axe :

>>> a= np.floor(10*np.random.random((3,4))) 
>>> a 
array([[ 7., 5., 9., 3.], 
      [ 7., 2., 7., 8.], 
      [ 6., 8., 3., 2.]]) 
>>> a.shape 
(3, 4)

La forme d'un tableau peut être modifiée de plusieurs manières :

>>> a.ravel() # 平坦化数组 
array([ 7., 5., 9., 3., 7., 2., 7., 8., 6., 8., 3., 2.]) 
>>> a.shape= (6, 2) 
>>> a.transpose() 
array([[ 7., 9., 7., 7., 6., 3.], 
      [ 5., 3., 2., 8., 8., 2.]])

L'ordre des éléments du tableau aplatis par ravel() est généralement, le "style C" est basé sur le comportement, et l'index le plus à droite change le plus rapidement, donc l'élément a[0,0] est suivi de a[0,1]. Si le tableau est remodelé dans une autre forme, le tableau est toujours de « style C ». NumPy crée généralement un tableau contenant les données dans cet ordre, donc ravel() n'a généralement pas besoin de créer une copie du tableau appelant. Mais si le tableau est découpé à travers un autre tableau ou comporte des options inhabituelles, vous devrez peut-être en créer une copie. Vous pouvez également utiliser certaines fonctions de paramètres facultatives pour laisser reshape() et ravel() construire un tableau de style FORTRAN, c'est-à-dire que l'index le plus à gauche change le plus rapidement.

La fonction reshape modifie la forme du tableau appelant et renvoie le tableau, tandis que la fonction resize modifie le tableau appelant lui-même.

>>> a 
array([[ 7., 5.], 
      [ 9., 3.], 
      [ 7., 2.], 
      [ 7., 8.], 
      [ 6., 8.], 
      [ 3., 2.]]) 
>>> a.resize((2,6)) 
>>> a 
array([[ 7., 5., 9., 3., 7., 2.], 
      [ 7., 8., 6., 8., 3., 2.]])

Si une dimension est spécifiée comme -1 lors de l'opération de remodelage, sa dimension précise sera calculée en fonction de la situation réelle

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'apprentissage de chacun. J'espère également que tout le monde soutiendra le site Web PHP chinois.

Pour une compréhension plus approfondie du didacticiel concis de NumPy --- Articles liés au tableau 2, veuillez faire attention au site Web PHP chinois !