Compréhension approfondie du didacticiel concis NumPy --- Tableau 1

Cet article présente principalement un tutoriel concis pour une compréhension approfondie de NumPy (2. Array 1). Le tableau NumPy est un objet tableau multidimensionnel et a une certaine valeur de référence.

Mon travail actuel consiste à introduire NumPy dans Pyston (un compilateur/interpréteur Python implémenté par Dropbox). Au cours du processus de travail, j'ai eu un contact approfondi avec le code source de NumPy, j'ai compris sa mise en œuvre et j'ai soumis un PR pour corriger les bugs de NumPy. En traitant du code source de NumPy et des développeurs de NumPy, j'ai constaté que la plupart des didacticiels chinois NumPy actuels sont traduits ou font référence à des documents anglais, ce qui conduit à de nombreuses omissions. Par exemple, la fonction de diffusion dans les tableaux NumPy est traduite par « diffusion » dans presque tous les documents chinois. L'un des développeurs de NumPy a répondu : "la diffusion est un composé - les anglophones natifs peuvent voir qu'il s'agit de " large » » cast » = « diffusion (diffusion, distribution) largement, je suppose « diffusion (diffusion, distribution) largement » probablement plus proche du sens (signification dans NumPy)". Dans cette perspective, je prévois de démarrer un projet pour écrire une série de tutoriels basés sur ma compréhension de l'utilisation de NumPy et du niveau du code source.

NumPy array

Un tableau NumPy est un objet tableau multidimensionnel appelé ndarray. Il se compose de deux parties :

• Les données réelles

• Métadonnées décrivant ces données

La plupart des opérations s'appliquent uniquement aux métadonnées et ne modifient pas les données réelles sous-jacentes

. quelques choses que vous devez savoir sur les tableaux NumPy :

• Les indices des tableaux NumPy commencent à 0.

• Tous les éléments du même tableau NumPy . Les types doivent être les mêmes. 🎜> Avant d'introduire les tableaux NumPy en détail, commençons par présenter les propriétés de base des tableaux NumPy. La dimension des tableaux NumPy est appelée rang. un tableau bidimensionnel est 2, et ainsi de suite. Dans NumPy, chaque tableau linéaire est appelé un (des) axe(s), et le rang décrit en fait le nombre d'axes. Par exemple, un tableau bidimensionnel équivaut à deux. -des tableaux dimensionnels, dont chacun est dans le premier tableau unidimensionnel. Chaque élément est un tableau unidimensionnel, donc le tableau unidimensionnel est l'axe (axes) dans NumPy. et le deuxième axe est le tableau dans le tableau sous-jacent. Le nombre d'axes - rang, c'est la dimension du tableau

Les propriétés d'objet ndarray les plus importantes de NumPy sont :
• <.>

  
  

  ndarray.ndim : La dimension du tableau (c'est-à-dire le nombre d'axes du tableau), égale au rang. Le plus courant est un tableau bidimensionnel (matrice). 🎜>
ndarray.shape : représente la dimension du tableau dans chaque dimension. Un tuple entier de taille supérieure. Par exemple, dans un tableau à deux dimensions, il représente le "nombre de lignes" et le "nombre de colonnes". du tableau. ndarray.shape renvoie un tuple, et la longueur de ce tuple est le nombre de dimensions, qui est l'attribut ndim >

ndarray.size : le nombre total d'éléments du tableau est. égal au produit des éléments du tuple dans l'attribut shape.

ndarray.dtype : Un objet représentant le type d'éléments dans le tableau. Le dtype peut être créé ou spécifié à l'aide de types Python standard. De plus, vous pouvez également utiliser les types de données fournis par NumPy introduits dans l'article précédent.

ndarray.itemsize : La taille en octets de chaque élément du tableau. Par exemple, la valeur de l'attribut itemsiz d'un tableau dont le type d'élément est float64 est 8 (float64 occupe 64 bits et chaque octet a une longueur de 8, donc 64/8 occupe 8 octets). Un autre exemple est un tableau dont le type d'élément est). complexe32. L'attribut de l'élément du tableau est 4 (32/8).

• ndarray.data : Un tampon contenant les éléments réels du tableau, puisque les éléments sont généralement obtenus via l'index du tableau, il n'est généralement pas nécessaire d'utiliser cet attribut.

• Création d'un tableau

• Présentons d'abord la création d'un tableau. Il existe de nombreuses façons de créer des tableaux. Par exemple, vous pouvez utiliser la fonction array pour créer des tableaux à partir de listes et de tuples Python classiques. Le type du tableau créé est dérivé des types d'éléments de la séquence d'origine.

• Lorsqu'il est créé à l'aide de la fonction tableau, le paramètre doit être une liste entourée de crochets et ne peut pas être appelé avec plusieurs valeurs comme tableau de paramètres. ​

Vous pouvez utiliser des séquences doubles pour représenter des tableaux à deux dimensions, des séquences triples pour représenter des tableaux à trois dimensions, etc.

Vous pouvez spécifier explicitement le type d'éléments dans le tableau lors de sa création

>>> from numpy import * 　　　 
>>> a = array( [2,3,4] )　　　 
>>> a 
  array([2, 3, 4]) 
>>> a.dtype 
  dtype('int32') 
>>> b = array([1.2, 3.5, 5.1])　　　 
>>> b.dtype 
  dtype('float64')

Habituellement, les éléments du tableau sont inconnus au début et la taille du tableau est connue. Par conséquent, NumPy fournit certaines fonctions pour créer des tableaux à l'aide d'espaces réservés. Ces fonctions aident à satisfaire le besoin d’expansion des tableaux tout en réduisant la charge de calcul élevée.

>>> a = array(1,2,3,4)  # 错误 
>>> a = array([1,2,3,4]) # 正确

Utilisez les zéros de fonction pour créer un tableau de tous les 0, utilisez les uns de fonction pour créer un tableau de tous les 1 et la fonction vide pour créer un tableau avec un contenu aléatoire et dépendant de l'état de la mémoire. Les types de tableaux (dtype) créés par défaut sont float64.

Vous pouvez utiliser d.dtype.itemsize pour vérifier le nombre d'octets occupés par les éléments du tableau.

>>> b = array( [ (1.5,2,3), (4,5,6) ] )　　 
>>> b 
  array([[ 1.5, 2. , 3. ], 
　　　   [ 4. , 5. , 6. ]])

Vous pouvez également spécifier vous-même le type d'éléments dans le tableau

>>> ones( (2,3,4), dtype=int16 ) #手动指定数组中元素类型 
   array([[[1, 1, 1, 1], 
　　　    [1, 1, 1, 1], 
　　　    [1, 1, 1, 1]], 
　　　 
　　　    [[1, 1, 1, 1], 
　　　    [1, 1, 1, 1], 
　　　    [1, 1, 1, 1]]], dtype=int16) 
>>> empty((2,3)) 
　　　array([[ 2.65565858e-316,  0.00000000e+000,  0.00000000e+000], 
　　　    [ 0.00000000e+000,  0.00000000e+000,  0.00000000e+000]])

NumPy提供一个类似arange的函数返回一个数列形式的数组:

>>> arange(10, 30, 5) 
  array([10, 15, 20, 25])

以10开始，差值为5的等差数列。该函数不仅接受整数，还接受浮点参数：　

>>> arange(0,2,0.5) 
  array([ 0. , 0.5, 1. , 1.5])

当arange使用浮点数参数时，由于浮点数精度有限，通常无法预测获得的元素个数。因此，最好使用函数linspace去接收我们想要的元素个数来代替用range来指定步长。linespace用法如下，将在通用函数一节中详细介绍。

>>> numpy.linspace(-1, 0, 5) 
    array([-1. , -0.75, -0.5 , -0.25, 0. ])

数组中的元素是通过下标来访问的，可以通过方括号括起一个下标来访问数组中单一一个元素，也可以以切片的形式访问数组中多个元素。关于切片访问，将在切片一节介绍。

知识点：NumPy中的数据类型

对于科学计算来说，Python中自带的整型、浮点型和复数类型远远不够，因此NumPy中添加了许多数据类型。如下：

NumPy中的基本数据类型

NumPy中的基本数据类型

名称	描述
bool	用一个字节存储的布尔类型（True或False）
inti	由所在平台决定其大小的整数（一般为int32或int64）
int8	一个字节大小，-128 至 127
int16	整数，-32768 至 32767
int32	整数，-2 ** 31 至 2 ** 32 -1
int64	整数，-2 ** 63 至 2 ** 63 - 1
uint8	无符号整数，0 至 255
uint16	无符号整数，0 至 65535
uint32	无符号整数，0 至 2 ** 32 - 1
uint64	无符号整数，0 至 2 ** 64 - 1
float16	半精度浮点数：16位，正负号1位，指数5位，精度10位
float32	单精度浮点数：32位，正负号1位，指数8位，精度23位
float64或float	双精度浮点数：64位，正负号1位，指数11位，精度52位
complex64	复数，分别用两个32位浮点数表示实部和虚部
complex128或complex	复数，分别用两个64位浮点数表示实部和虚部

NumPy类型转换方式如下：

>>> float64(42) 
  42.0 
>>> int8(42.0) 
  42 
>>> bool(42) 
  True 
>>> bool(42.0) 
  True 
>>> float(True) 
  1.0

许多函数的参数中可以指定参数的类型，当然，这个类型参数是可选的。如下：

>>> arange(7, dtype=uint16) 
  array([0, 1, 2, 3, 4, 5, 6], dtype=uint16)

输出数组

当输出一个数组时，NumPy以特定的布局用类似嵌套列表的形式显示：

• 第一行从左到右输出

• 每行依次自上而下输出

• 每个切片通过一个空行与下一个隔开

• 一维数组被打印成行，二维数组成矩阵，三维数组成矩阵列表。　

>>> a = arange(6)             # 1d array 
>>> print a 
  [0 1 2 3 4 5] 
　　　 
>>> b = arange(12).reshape(4,3)      # 2d array 
>>> print b 
  [[ 0 1 2] 
  [ 3 4 5] 
  [ 6 7 8] 
  [ 9 10 11]]　　　 
>>> c = arange(24).reshape(2,3,4)     # 3d array 
>>> print c 
  [[[ 0 1 2 3] 
  [ 4 5 6 7] 
  [ 8 9 10 11]] 
　　　 
  [[12 13 14 15] 
  [16 17 18 19] 
  [20 21 22 23]]]

reshape将在下一篇文章中介绍　

如果一个数组太长，则NumPy自动省略中间部分而只打印两端的数据：　　　

>>> print arange(10000) 
　　　[  0  1  2 ..., 9997 9998 9999] 
　　　 
>>> print arange(10000).reshape(100,100) 
　　　[[  0  1  2 ...,  97  98  99] 
　　　 [ 100 101 102 ..., 197 198 199] 
　　　 [ 200 201 202 ..., 297 298 299] 
　　　 ..., 
　　　 [9700 9701 9702 ..., 9797 9798 9799] 
　　　 [9800 9801 9802 ..., 9897 9898 9899] 
　　　 [9900 9901 9902 ..., 9997 9998 9999]]

可通过设置printoptions参数来禁用NumPy的这种行为并强制打印整个数组。

set_printoptions(threshold='nan')

这样，输出时数组的所有元素都会显示出来。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持PHP中文网。

更多深入理解NumPy简明教程---数组1相关文章请关注PHP中文网！