Numpy中的N维数组 ndarray

📌 相关文章

📜 Numpy中的N维数组 ndarray

📅 最后修改于: 2020-04-18 08:57:25 🧑 作者: Mango

Numpy中的N维数组(ndarray)

Numpy中的Array是元素表(通常是数字)，所有元素都是相同类型的，由正整数元组索引。在Numpy中，数组的维数称为数组的秩。给出每个方向的数组大小的整数元组称为数组的形状。Numpy中的数组类称为ndarray。Numpy数组中的元素可以使用方括号访问，并且可以使用嵌套的Python列表进行初始化。
范例：

[[ 1, 2, 3],
      [ 4, 2, 5]]
在这里，rank= 2(因为它是二维或具有2个轴)
第一维(轴)长度= 2，第二维的长度= 3
整体形状可以表示为：(2，3)

# 用Python程序演示基本数组特性
import numpy as np
# 创建数组对象
arr = np.array( [[ 1, 2, 3],
                 [ 4, 2, 5]] )
# 打印arr对象的类型
print("数组的类型是: ", type(arr))
# 打印数组尺寸(轴)
print("维度 : ", arr.ndim)
# 打印数组的形状
print("数组维度: ", arr.shape)
# 数组的打印大小(元素总数)
print("数组大小: ", arr.size)
# 打印数组中元素的类型
print("数组存储类型的元素: ", arr.dtype)

输出：

数组的类型是:  
维度:  2
数组维度:  (2, 3)
数组大小:  6
数组存储类型的元素:  int64

数组创建

在NumPy中有多种创建数组的方法。

例如，您可以使用array函数从常规Python 列表或元组创建数组。根据序列中元素的类型推导所得数组的类型。
通常，数组的元素最初是未知的，但是其大小是已知的。因此，NumPy提供了几个函数来创建具有初始占位符内容的数组。这些将增长阵列的必要性降至最低，这是一项昂贵的操作。
例如： np.zeros，np.ones，np.full，np.empty等。
为了创建数字序列，NumPy提供了类似于range的函数，该函数返回数组而不是列表。
arange：返回给定间隔内的均匀间隔的值。指定步长。
linspace：返回给定间隔内的均匀间隔的值。
reshape数组：我们可以使用重塑方法重塑数组。考虑一个形状为(a1，a2，a3，…，aN)的数组。我们可以重塑形状并将其转换为形状为(b1，b2，b3，…，bM)的另一个数组。唯一需要的条件是：
a1 x a2 x a3…x aN = b1 x b2 x b3…x bM。(即数组总的大小保持不变。)
展平数组：我们可以使用展平方法将数组副本折叠为一个维度。它接受顺序参数，默认值为“ C”(对于行优先)。使用“ F”表示主要顺序。

注意：创建数组时可以显式定义数组的类型。

# Python程序演示数组创建技术
import numpy as np
# 从类型为float的列表创建数组
a = np.array([[1, 2, 4], [5, 8, 7]], dtype = 'float')
print ("使用传递的列表创建的数组:\n", a)
# 从元组创建数组
b = np.array((1 , 3, 2))
print ("\n使用传递的元组创建的数组:\n", b)
# 创建一个全零的3X4数组
c = np.zeros((3, 4))
print ("\n用全零初始化的数组:\n", c)
# 创建复杂类型的常量值数组
d = np.full((3, 3), 6, dtype = 'complex')
print ("\n用所有元素都是6初始化的数组."
            "数组类型是复数:\n", d)

输出：

使用传递的列表创建的数组:
 [[ 1.  2.  4.]
 [ 5.  8.  7.]]
使用传递的元组创建的数组:
 [1 3 2]
用全零初始化的数组:
 [[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]
用所有元素都是6初始化的数组. 数组类型是复数:
 [[ 6.+0.j  6.+0.j  6.+0.j]
 [ 6.+0.j  6.+0.j  6.+0.j]
 [ 6.+0.j  6.+0.j  6.+0.j]]

数组索引

了解数组索引的基础对于分析和操作数组对象很重要。NumPy提供了许多进行数组索引的方法。

切片：就像Python中的列表一样，NumPy数组也可以切片。由于数组可以是多维的，因此您需要为数组的每个维度指定一个切片。
整数数组索引：在此方法中，将传递列表以为每个维建立索引。完成了对应元素的一对一映射，以构造一个新的任意数组。

布尔数组索引：当我们要从满足条件的数组中选择元素时，使用此方法。

# Python程序演示numpy中的索引
import numpy as np
# 示例数组
arr = np.array([[-1, 2, 0, 4],
                [4, -0.5, 6, 0],
                [2.6, 0, 7, 8],
                [3, -7, 4, 2.0]])
# 切片阵列
temp = arr[:2, ::2]
print ("具有前两行和备用行的数组"
                    "列(0和2):\n", temp)
# 整数数组索引示例
temp = arr[[0, 1, 2, 3], [3, 2, 1, 0]]
print ("\n索引元素 (0, 3), (1, 2), (2, 1),"
                                    "(3, 0):\n", temp)
# 布尔数组索引示例
cond = arr > 0 # cond是一个布尔数组
temp = arr[cond]
print ("\n大于0的元素:\n", temp)

输出：

具有前2行和交替列(0和2)的数组:
 [[-1.  0.]
 [ 4.  6.]]
索引元素 (0, 3), (1, 2), (2, 1),(3, 0):
 [ 4.  6.  0.  3.]
大于 0:
 [ 2.   4.   4.   6.   2.6  7.   8.   3.   4.   2. ]

基本操作

NumPy提供了内置算术函数的Plethora。

对单个数组的运算：我们可以使用重载算术运算符对数组进行按元素运算以创建新数组。在+=，-=，*=运算符的情况下，修改现有数组。

# Python程序演示单个数组上的基本操作
import numpy as np
a = np.array([1, 2, 5, 3])
# 给每个元素加1
print ("每个元素加1:", a+1)
# 从每个元素中减去3
print ("从每个元素中减去3:", a-3)
# 每个元素乘以10
print ("每个元素乘以10:", a*10)
# 平方每个元素
print ("平方每个元素:", a**2)
# 修改现有数组
a *= 2
print ("将原始数组的每个元素加倍:", a)
# 数组转置
a = np.array([[1, 2, 3], [3, 4, 5], [9, 6, 0]])
print ("\n原始阵列:\n", a)
print ("数组转置:\n", a.T)

输出：

每个元素加1: [2 3 6 4]
从每个元素中减去3: [-2 -1  2  0]
每个元素乘以10: [10 20 50 30]
平方每个元素: [ 1  4 25  9]
将原始数组的每个元素加倍: [ 2  4 10  6]
原始阵列:
 [[1 2 3]
 [3 4 5]
 [9 6 0]]
数组转置:
 [[1 3 9]
 [2 4 6]
 [3 5 0]]

一元运算符：许多一元运算作为ndarray类的方法提供。这包括总和，最小值，最大值等。也可以通过设置轴参数来逐行或逐列应用这些功能。

# Python程序演示numpy中的一元运算符
import numpy as np
arr = np.array([[1, 5, 6],
                [4, 7, 2],
                [3, 1, 9]])
# 数组的最大元素
print ("最大元素是:", arr.max())
print ("按行最大元素:",
                    arr.max(axis = 1))
# 数组的最小元素
print ("列式最小元素:",
                        arr.min(axis = 0))
# 数组元素之和
print ("所有数组元素的总和:",
                            arr.sum())
# 每行的累计总和
print ("每一行的累计总和:\n",
                        arr.cumsum(axis = 1))

输出：

最大元素是: 9
按行最大元素: [6 7 9]
列式最小元素: [1 1 2]
所有数组元素的总和: 38
每一行的累计总和:
[[ 1  6 12]
 [ 4 11 13]
 [ 3  4 13]]

二进制运算符：这些运算适用于元素数组，并创建一个新数组。您可以使用所有基本的算术运算符，例如+，-，/，等。对于+=，-=， =运算符，将修改现有的数组。

# Python程序在Numpy中演示二进制运算符
import numpy as np
a = np.array([[1, 2],
            [3, 4]])
b = np.array([[4, 3],
            [2, 1]])
# 添加数组
print ("数组总和:\n", a + b)
# 乘法数组(逐元素乘法)
print ("数组乘法:\n", a*b)
# 矩阵乘法
print ("矩阵乘法:\n", a.dot(b))

输出：

数组总和:
[[5 5]
 [5 5]]
数组乘法:
[[4 6]
 [6 4]]
矩阵乘法:
[[ 8  5]
 [20 13]]

通用函数(ufunc)： NumPy提供了熟悉的数学函数，例如sin，cos，exp等。这些函数还在数组上逐元素进行操作，从而生成数组作为输出。注意：上面我们使用重载运算符执行的所有操作都可以使用ufuncs来完成，例如np.add，np.subtract，np.multiply，np.divide，np.sum等。

# Python程序演示numpy中的通用函数
import numpy as np
# 创建一个正弦值数组
a = np.array([0, np.pi/2, np.pi])
print ("数组元素的正弦值:", np.sin(a))
# 指数值
a = np.array([0, 1, 2, 3])
print ("数组元素的指数:", np.exp(a))
# 数组值的平方根
print ("数组元素的平方根:", np.sqrt(a))

输出：

数组元素的正弦值: [  0.00000000e+00   1.00000000e+00   1.22464680e-16]
数组元素的指数: [  1.           2.71828183   7.3890561   20.08553692]
数组元素的平方根: [ 0.          1.          1.41421356  1.73205081]

数据类型

每个ndarray都有一个关联的数据类型(dtype)对象。此数据类型对象(dtype)告知我们有关数组布局的信息。这意味着它为我们提供了有关以下信息：

数据类型(整数，浮点数，Python对象等)
数据大小(字节数)
数据的字节顺序(小端或大端)
如果数据类型是子数组，则其形状和数据类型分别是什么。

ndarray的值存储在缓冲区中，可以将其视为内存字节的连续块。因此，如何解释这些字节由dtype对象给出。
每个Numpy数组都是一个元素表(通常是数字)，所有元素都是相同类型的，并由一个正整数元组索引。每个ndarray都有一个关联的数据类型(dtype)对象。

该数据类型对象(dtype)提供有关数组布局的信息。ndarray的值存储在缓冲区中，缓冲区可以被认为是连续的存储字节块，可以由dtype对象解释。Numpy提供了大量可用于构造数组的数据类型。
在创建数组时，Numpy会尝试猜测一个数据类型，但是构造数组的函数通常还包含一个可选参数来显式指定该数据类型。

# Python程序创建数据类型对象
import numpy as np
# np.int16转换为数据类型对象.
print(np.dtype(np.int16))

输出：

int16

# Python程序创建包含32位大端整数的数据类型对象
import numpy as np
# i4代表大小为4字节的整数
# >表示大端字节序，而<表示小端字节编码。
# dt是dtype对象
dt = np.dtype('>i4')
print("字节顺序为:",dt.byteorder)
print("尺寸为:",dt.itemsize)
print("数据类型为:",dt.name)

输出：

字节顺序为: >
尺寸为: 4
数据类型为: int32