Detailliertes Verständnis des prägnanten NumPy-Tutorials --- Array 1

Dieser Artikel stellt hauptsächlich ein prägnantes Tutorial zum detaillierten Verständnis von NumPy vor (2. Das NumPy-Array ist ein mehrdimensionales Array-Objekt und hat einen gewissen Referenzwert.)

Mein aktueller Job ist die Einführung von NumPy in Pyston (einen von Dropbox implementierten Python-Compiler/Interpreter). Während des Arbeitsprozesses hatte ich intensiven Kontakt mit dem NumPy-Quellcode, verstand seine Implementierung und reichte eine PR ein, um NumPy-Fehler zu beheben. Im Umgang mit NumPy-Quellcode und NumPy-Entwicklern habe ich festgestellt, dass die meisten aktuellen chinesischen NumPy-Tutorials übersetzt sind oder auf englische Dokumente verweisen, was zu vielen Auslassungen führt. Beispielsweise wird die Broadcast-Funktion in NumPy-Arrays in fast allen chinesischen Dokumenten mit „Broadcast“ übersetzt. Einer der Entwickler von NumPy antwortete: „Broadcast ist eine Verbindung – englische Muttersprachler können erkennen, dass es „breit“ + „cast“ = „cast (streuen, verteilen) im Großen und Ganzen“ ist, ich schätze „cast (streuen, verteilen) im Großen und Ganzen“ liegt wahrscheinlich näher an der Bedeutung (Bedeutung in NumPy)“. Vor diesem Hintergrund plane ich, ein Projekt zu starten, um eine Reihe von Tutorials zu schreiben, die auf meinem Verständnis der NumPy-Nutzung und der Quellcodeebene basieren. >NumPy-Array

Ein NumPy-Array ist ein mehrdimensionales Array-Objekt, das als ndarray bezeichnet wird. Es besteht aus zwei Teilen:

Die eigentlichen Daten

• Metadaten, die diese Daten beschreiben

• Die meisten Vorgänge zielen nur auf Metadaten ab und ändern nicht die zugrunde liegenden tatsächlichen Daten >Es gibt ein paar Dinge, die Sie über NumPy-Arrays wissen müssen:

Die Indizes von NumPy-Arrays beginnen bei 0.

• Alle im selben NumPy-Array müssen

• Bevor wir das NumPy-Array im Detail vorstellen, stellen wir zunächst die grundlegenden Eigenschaften des NumPy-Arrays vor. Die Dimension des NumPy Der Rang eines eindimensionalen Arrays ist 1 und der Rang eines zweidimensionalen Arrays ist 2. In NumPy wird jedes lineare Array als Achse (Achsen) bezeichnet, und der Rang beschreibt tatsächlich Die Anzahl der Achsen entspricht beispielsweise zwei eindimensionalen Arrays, wobei das erste eindimensionale Array gleich ist Achsen (Achsen) in NumPy entsprechen dem zugrunde liegenden Array und die zweite Achse ist die Anzahl der Achsen im zugrunde liegenden Array Weitere wichtige Ndarray-Objekteigenschaften von NumPy sind:
  

ndarray.ndim: die Dimension des Arrays (d. h. die Anzahl der Array-Achsen), gleich dem Rang. Am gebräuchlichsten ist ein zweidimensionales Array (Matrix). ndarray.shape: Stellt die Dimension des Arrays dar. In einem zweidimensionalen Array stellt es beispielsweise „ dar. Anzahl der Zeilen“ und „Anzahl der Spalten“ des Arrays. ndarray.shape gibt ein Tupel zurück, und die Länge dieses Tupels ist die Anzahl der Dimensionen, also das ndim-Attribut. 🎜>

ndarray.size: Die Gesamtzahl der Array-Elemente entspricht dem Produkt der Tupelelemente im Shape-Attribut.

ndarray.dtype: Ein Objekt, das den Typ der Elemente im Array darstellt. Der dtype kann mit Standard-Python-Typen erstellt oder angegeben werden. Darüber hinaus können Sie auch die im vorherigen Artikel vorgestellten Datentypen von NumPy verwenden.

• ndarray.itemsize: Die Bytegröße jedes Elements im Array. Beispielsweise beträgt der Attributwert „itemsiz“ eines Arrays mit dem Elementtyp „float64“ 8 (float64 belegt 64 Bit und jedes Byte ist 8 Bytes lang, also 64/8, also 8 Bytes). Ein weiteres Beispiel ist ein Array mit dem Elementtyp „float64“. complex32. Das Array-Elementattribut ist 4 (32/8).

• ndarray.data: Ein Puffer, der die tatsächlichen Array-Elemente enthält. Da Elemente im Allgemeinen über den Index des Arrays abgerufen werden, besteht normalerweise keine Notwendigkeit, dieses Attribut zu verwenden.

• Erstellen eines Arrays

• Lassen Sie uns zunächst das Erstellen eines Arrays vorstellen. Es gibt viele Möglichkeiten, Arrays zu erstellen. Mit der Array-Funktion können Sie beispielsweise Arrays aus regulären Python-Listen und -Tupeln erstellen. Der Typ des erstellten Arrays wird von den Elementtypen in der Originalsequenz abgeleitet.

• Bei der Erstellung mit der Array-Funktion muss der Parameter eine in eckige Klammern eingeschlossene Liste sein und kann nicht mit mehreren Werten aufgerufen werden als Parameter-Array. ​

Sie können Doppelsequenzen zur Darstellung zweidimensionaler Arrays, Dreifachsequenzen zur Darstellung dreidimensionaler Arrays usw. verwenden.

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

Sie können den Typ der Elemente im Array beim Erstellen explizit angeben

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

Normalerweise sind die Elemente des Arrays zu Beginn unbekannt und die Größe des Arrays ist bekannt. Daher bietet NumPy einige Funktionen zum Erstellen von Arrays mithilfe von Platzhaltern. Diese Funktionen tragen dazu bei, den Bedarf an Array-Erweiterungen zu decken und gleichzeitig den hohen Rechenaufwand zu reduzieren.

Verwenden Sie die Funktion Nullen, um ein Array aller Nullen zu erstellen, verwenden Sie die Funktion Einsen, um ein Array aller Einsen zu erstellen, und die Funktion Leer, um ein Array mit zufälligem Inhalt zu erstellen, der vom Speicherstatus abhängt. Die standardmäßig erstellten Array-Typen (dtype) sind float64.

Sie können d.dtype.itemsize verwenden, um die Anzahl der von Elementen im Array belegten Bytes zu überprüfen.

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

Sie können die Art der Elemente im Array auch selbst festlegen

>>> c = array( [ [1,2], [3,4] ], dtype=complex) 
>>> c 
  array([[ 1.+0.j, 2.+0.j], 
　　　  [ 3.+0.j, 4.+0.j]])

>>> 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中文网！