介绍#

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

• 一个强大的N维数组对象 ndarray
• 广播功能函数
• 整合 C/C++/Fortran 代码的工具
• 线性代数、傅里叶变换、随机数生成等功能

应用#

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用

这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。

SciPy 是一个开源的 Python 算法库和数学工具包。

SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。

Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。

它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）。

安装#

• 安装发行版
• pip安装pip3 install numpy scipy matplotlib

安装验证

1
from numpy import *
2
eye(4)

Numpy Ndarray对象#

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

ndarray 内部由以下内容组成：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。
• 数据类型或 dtype，描述在数组中的固定大小值的格子。
• 一个表示数组形状（shape）的元组，表示各维度大小的元组。
• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要”跨过”的字节数。

ndarray 对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素。

1
numpy.array(object,dtype = None,copy = True,order = None,subok = False,ndmin = 0)
2

3
# object:数组或嵌套的数列
4
# dtype:数组元素的数据类型，可选
5
# copy:对象是否需要复制，可选
6
# order:创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
7
# subok:默认返回一个与基类类型一致的数组
8
# ndmin:指定生成数组的最小维度

1
import numpy as np
2
a = np.array([1,2,3])
3
print (a)
4

5
a = np.array([[1,  2],  [3,  4]])
6
print (a)
7

8
# 最小维度
9
a = np.array([1, 2, 3, 4, 5], ndmin =  2)
10
print (a)
11

12
# dtype 参数
13
a = np.array([1,  2,  3], dtype = complex)
14
print (a)

数据类型#

numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。

bool,int,intc,intp,int8,int16,int32,int64,uint8,uint16,uint32,uint64,float,float16,float32,float64,complex_,complex128,complex64,complex128

数据类型对象（numpy.dtype 类的实例）用来描述与数组对应的内存区域是如何使用，它描述了数据的以下几个方面：：

• 数据的类型（整数，浮点数或者 Python 对象）
• 数据的大小（例如， 整数使用多少个字节存储）
• 数据的字节顺序（小端法或大端法）
• 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
• 如果数据类型是子数组，那么它的形状和数据类型是什么。

字节顺序是通过对数据类型预先设定 < 或 > 来决定的。 < 意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。> 意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。

dtype 对象是使用以下语法构造的：

1
numpy.dtype(object, align, copy)
2

3
# object - 要转换为的数据类型对象
4
# align - 如果为 true，填充字段使其类似 C 的结构体。
5
# copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

使用：

1
import numpy as np
2
# 使用标量类型
3
dt = np.dtype(np.int32)
4
print(dt)
5

6
# 首先创建结构化数据类型
7
dt = np.dtype([('age',np.int8)])
8
# 将数据类型应用于 ndarray 对象
9
a = np.array([(10,),(20,),(30,)], dtype = dt)
10
print(a)

每个内建类型都有一个唯一定义它的字符代码，如下：

Numpy数组属性#

NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。

所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

NumPy 的数组中比较重要 ndarray 对象属性有：

• ndarray.ndim 秩，即轴的数量或维度的数量

  1
  import numpy as np
  2
  
  3
  a = np.arange(24)
  4
  print (a.ndim)             # a 现只有一个维度
  5
  # 现在调整其大小
  6
  b = a.reshape(2,4,3)  # b 现在拥有三个维度
  7
  print (b.ndim)

• ndarray.shape 数组的维度，对于矩阵，n 行 m 列

  ndarray.shape 也可以用于调整数组大小。

  NumPy 也提供了 reshape 函数来调整数组大小。

  1
  import numpy as np
  2
  
  3
  a = np.array([[1,2,3],[4,5,6]])
  4
  print (a.shape)
  5
  
  6
  a.shape =  (3,2)
  7
  print (a)
  8
  
  9
  a = np.array([[1,2,3],[4,5,6]])
  10
  b = a.reshape(3,2)
  11
  print (b)

• ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值

• ndarray.dtype ndarray 对象的元素类型

• ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位

  1
  import numpy as np
  2
  
  3
  # 数组的 dtype 为 int8（一个字节）
  4
  x = np.array([1,2,3,4,5], dtype = np.int8)
  5
  print (x.itemsize)
  6
  
  7
  # 数组的 dtype 现在为 float64（八个字节）
  8
  y = np.array([1,2,3,4,5], dtype = np.float64)
  9
  print (y.itemsize)

• ndarray.flags ndarray 对象的内存信息

  属性	描述
  C_CONTIGUOUS (C)	数据是在一个单一的C风格的连续段中
  F_CONTIGUOUS (F)	数据是在一个单一的Fortran风格的连续段中
  OWNDATA (O)	数组拥有它所使用的内存或从另一个对象中借用它
  WRITEABLE (W)	数据区域可以被写入，将该值设置为 False，则数据为只读
  ALIGNED (A)	数据和所有元素都适当地对齐到硬件上
  UPDATEIFCOPY (U)	这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新

  1
  import numpy as np
  2
  
  3
  x = np.array([1,2,3,4,5])
  4
  print (x.flags)

• ndarray.real ndarray元素的实部

• ndarray.imag ndarray 元素的虚部

• ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性

创建Numpy数组#

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。

• numpy.empty

  numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

  1
  numpy.empty(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order  有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

  使用：

  1
  import numpy as np
  2
  x = np.empty([3,2], dtype = int)
  3
  print (x)

• numpy.zeros

  创建指定大小的数组，数组元素以 0 来填充：

  1
  numpy.zeros(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order  'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

  使用：

  1
  import numpy as np
  2
  
  3
  # 默认为浮点数
  4
  x = np.zeros(5)
  5
  print(x)
  6
  
  7
  # 设置类型为整数
  8
  y = np.zeros((5,), dtype = int)
  9
  print(y)
  10
  
  11
  # 自定义类型
  12
  z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
  13
  print(z)

• numpy.ones

  创建指定形状的数组，数组元素以 1 来填充：

  1
  numpy.ones(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order    'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

  使用：

  1
  import numpy as np
  2
  
  3
  # 默认为浮点数
  4
  x = np.ones(5)
  5
  print(x)
  6
  
  7
  # 自定义类型
  8
  x = np.ones([2,2], dtype = int)
  9
  print(x)

• numpy.zeros_like/ones_like

  numpy.zeros_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充。

  numpy.zeros 和 numpy.zeros_like 都是用于创建一个指定形状的数组，其中所有元素都是 0。

  它们之间的区别在于：numpy.zeros 可以直接指定要创建的数组的形状，而 numpy.zeros_like 则是创建一个与给定数组具有相同形状的数组。

  1
  numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
  2
  
  3
  # a  给定要创建相同形状的数组
  4
  # dtype  创建的数组的数据类型
  5
  # order  数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）
  6
  # subok  是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组
  7
  # shape  创建的数组的形状，如果不指定，则默认为 a 数组的形状。

  使用：

  1
  import numpy as np
  2
  
  3
  # 创建一个 3x3 的二维数组
  4
  arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
  5
  
  6
  # 创建一个与 arr 形状相同的，所有元素都为 0 的数组
  7
  zeros_arr = np.zeros_like(arr)
  8
  print(zeros_arr)

数组的切片和索引#

1
import numpy as np
2

3
a = np.arange(10)
4
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
5
print (a[s])
6

7
# 也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作
8
a = np.arange(10)
9
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
10
print(b)
11

12
a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
13
b = a[5]
14
print(b)
15

16
print(a[2:])
17

18
print(a[2:5])
19

20
# 多维
21
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
22
print(a)
23
# 从某个索引处开始切割
24
print('从数组索引 a[1:] 处开始切割')
25
print(a[1:])
26

27
# 省略号
28
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
29
print (a[...,1])   # 第2列元素
30
print (a[1,...])   # 第2行元素
31
print (a[...,1:])  # 第2列及剩下的所有元素

高级索引#

NumPy 比一般的 Python 序列提供更多的索引方式。

除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。

NumPy 中的高级索引指的是使用整数数组、布尔数组或者其他序列来访问数组的元素。相比于基本索引，高级索引可以访问到数组中的任意元素，并且可以用来对数组进行复杂的操作和修改。

1
import numpy as np
2

3
# 获取数组中 (0,0)，(1,1) 和 (2,0) 位置处的元素
4
x = np.array([[1,  2],  [3,  4],  [5,  6]])
5
y = x[[0,1,2],  [0,1,0]]
6
print (y)
7

8
# 获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]
9
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])
10
print ('我们的数组是：' )
11
print (x)
12
print ('\\n')
13
rows = np.array([[0,0],[3,3]])
14
cols = np.array([[0,2],[0,2]])
15
y = x[rows,cols]
16
print  ('这个数组的四个角元素是：')
17
print (y)
18

19
# 可以借助切片 : 或 … 与索引数组组合
20
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
21
b = a[1:3, 1:3]
22
c = a[1:3,[1,2]]
23
d = a[...,1:]
24
print(b)
25
print(c)
26
print(d)

1
import numpy as np
2

3
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])
4
print ('我们的数组是：')
5
print (x)
6
print ('\\n')
7
# 现在我们会打印出大于 5 的元素
8
print  ('大于 5 的元素是：')
9
print (x[x >  5])
10

11
a = np.array([np.nan,  1,2,np.nan,3,4,5])
12
print (a[~np.isnan(a)])
13

14
a = np.array([1,  2+6j,  5,  3.5+5j])
15
print (a[np.iscomplex(a)])

广播 broadcast#

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。

如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。4x3 的二维数组与长为 3 的一维数组相加，等效于把数组 b 在二维上重复 4 次再运算：

1
import numpy as np
2

3
a = np.array([[ 0, 0, 0],
4
           [10,10,10],
5
           [20,20,20],
6
           [30,30,30]])
7
b = np.array([0,1,2])
8
print(a + b)
9

10
bb = np.tile(b, (4, 1))  # 重复 b 的各个维度
11
print(a + bb)

广播的规则:

1. 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
2. 输出数组的形状是输入数组形状的各个维度上的最大值。
3. 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
4. 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

若条件不满足，抛出 “ValueError: frames are not aligned” 异常。

迭代数组#

NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。

迭代器最基本的任务的可以完成对数组元素的访问。

1
import numpy as np
2

3
a = np.arange(6).reshape(2,3)
4
print ('原始数组是：')
5
print (a,'\\n')
6
print ('迭代输出元素：')
7
for x in np.nditer(a):
8
    print (x, end=", " )
9
print ('\\n')
10

11
for x in np.nditer(a.T):
12
    print (x, end=", " )
13
print ('\\n')
14

15
for x in np.nditer(a.T.copy(order='C')):
16
    print (x, end=", " )
17
print ('\\n')

从上述例子可以看出，a 和 a.T 的遍历顺序是一样的，也就是他们在内存中的存储顺序也是一样的，但是 a.T.copy(order = ‘C’) 的遍历结果是不同的，那是因为它和前两种的存储方式是不一样的。nditer默认是按K顺序，即尽可能接近数组元素在内存中的显示数据。

1
import numpy as np
2

3
a = np.arange(0,60,5)
4
a = a.reshape(3,4)
5
print ('原始数组是：')
6
print (a)
7
print ('\\n')
8
print ('原始数组的转置是：')
9
b = a.T
10
print (b)
11
print ('\\n')
12
print ('以 C 风格顺序排序：')
13
c = b.copy(order='C')
14
print (c)
15
for x in np.nditer(c):
16
    print (x, end=", " )
17
print  ('\\n')
18
print  ('以 F 风格顺序排序：')
19
c = b.copy(order='F')
20
print (c)
21
for x in np.nditer(c):
22
    print (x, end=", " )
23
print  ('\\n')
24
# 可以通过显式设置，来强制 nditer 对象使用某种顺序：
25
print ('以 C 风格顺序排序：')
26
for x in np.nditer(a, order =  'C'):
27
    print (x, end=", " )
28
print ('\\n')
29
print ('以 F 风格顺序排序：')
30
for x in np.nditer(a, order =  'F'):
31
    print (x, end=", " )

1
import numpy as np
2

3
a = np.arange(0,60,5)
4
a = a.reshape(3,4)
5
print ('原始数组是：')
6
print (a)
7
print ('\\n')
8
for x in np.nditer(a, op_flags=['readwrite']):
9
    x[...]=2*x
10
print ('修改后的数组是：')
11
print (a)

1
import numpy as np
2
a = np.arange(0,60,5)
3
a = a.reshape(3,4)
4
print ('原始数组是：')
5
print (a)
6
print ('\\n')
7
print ('修改后的数组是：')
8
for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):
9
   print (x, end=", " )

1
import numpy as np
2

3
a = np.arange(0,60,5)
4
a = a.reshape(3,4)
5
print  ('第一个数组为：')
6
print (a)
7
print  ('\\n')
8
print ('第二个数组为：')
9
b = np.array([1,  2,  3,  4], dtype =  int)
10
print (b)
11
print ('\\n')
12
print ('修改后的数组为：')
13
for x,y in np.nditer([a,b]):
14
    print ("%d:%d"  %  (x,y), end=", " )

数组操作#

Introduction#

NumPy(Numerical Python) is an extension library for the Python language that supports extensive multi-dimensional array and matrix operations, and also provides a large collection of mathematical functions for array operations.

NumPy is a fast mathematical library, primarily used for array computations, and includes:

• A powerful N-dimensional array object ndarray
• Broadcasting function facilities
• Tools for integrating C/C++/Fortran code
• Functions for linear algebra, Fourier transforms, random number generation, and more

Applications#

NumPy is typically used together with SciPy (Scientific Python) and Matplotlib (the plotting library)

This combination is widely used as a replacement for MATLAB and provides a powerful scientific computing environment, helping us learn data science or machine learning through Python.

SciPy is an open-source Python algorithms library and mathematical toolkit.

SciPy includes modules for optimization, linear algebra, integration, interpolation, special functions, fast Fourier transforms, signal processing and image processing, solving ordinary differential equations, and other computations commonly used in science and engineering.

Matplotlib is the visualization interface for Python programming language and its NumPy numerical extension package.

It provides an API for embedding plots into applications using common GUI toolkits such as Tkinter, wxPython, Qt, or GTK+.

Installation#

• Install from a distribution package
• Install via pip: pip3 install numpy scipy matplotlib

Installation verification

1
from numpy import *
2
eye(4)

NumPy ndarray Object#

One of NumPy’s most important features is its N-dimensional array object, ndarray. It is a collection of elements of the same type, indexed from 0.

An ndarray object is a multidimensional array used to store elements of the same type.

Each element in an ndarray occupies a memory region of the same size.

An ndarray internally consists of the following parts:

• A pointer to the data (a block in memory or in a memory-mapped file).
• A data type (dtype) that describes the fixed-size element slots in the array.
• A tuple representing the array shape, i.e., the size of each dimension.
• A stride tuple, whose integers indicate how many bytes to skip to move to the next element along each dimension.

An ndarray consists of a contiguous one-dimensional memory block plus an indexing scheme that maps each element to a position in that block. Elements are stored in row-major order (C-style) or column-major order (FORTRAN/MatLab-style, i.e. F-order).

1
numpy.array(object,dtype = None,copy = True,order = None,subok = False,ndmin = 0)
2

3
# object:数组或嵌套的数列
4
# dtype:数组元素的数据类型，可选
5
# copy:对象是否需要复制，可选
6
# order:创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
7
# subok:默认返回一个与基类类型一致的数组
8
# ndmin:指定生成数组的最小维度

1
import numpy as np
2
a = np.array([1,2,3])
3
print (a)
4

5
a = np.array([[1,  2],  [3,  4]])
6
print (a)
7

8
# 最小维度
9
a = np.array([1, 2, 3, 4, 5], ndmin =  2)
10
print (a)
11

12
# dtype 参数
13
a = np.array([1,  2,  3], dtype = complex)
14
print (a)

Data Types#

NumPy supports many more data types than Python built-ins, and most of them correspond to C language data types. Some of them also map to Python built-in types.

bool,int,intc,intp,int8,int16,int32,int64,uint8,uint16,uint32,uint64,float,float16,float32,float64,complex_,complex128,complex64,complex128

A data type object (an instance of numpy.dtype) describes how the memory area corresponding to an array is used. It describes the following aspects of the data:

• The data type (integer, floating point, or Python object)
• The size of the data (for example, how many bytes an integer uses)
• The byte order of the data (little-endian or big-endian)
• For structured types, the field names, each field’s data type, and the portion of memory occupied by each field
• If the data type is a sub-array, its shape and data type

Byte order is determined by prefixing the data type with < or >. < means little-endian (least significant bytes at lower addresses), and > means big-endian (most significant bytes at lower addresses).

A dtype object is constructed using the following syntax:

1
numpy.dtype(object, align, copy)
2

3
# object - 要转换为的数据类型对象
4
# align - 如果为 true，填充字段使其类似 C 的结构体。
5
# copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

Usage:

1
import numpy as np
2
# 使用标量类型
3
dt = np.dtype(np.int32)
4
print(dt)
5

6
# 首先创建结构化数据类型
7
dt = np.dtype([('age',np.int8)])
8
# 将数据类型应用于 ndarray 对象
9
a = np.array([(10,),(20,),(30,)], dtype = dt)
10
print(a)

Each built-in type has a unique character code, as shown below:

NumPy Array Attributes#

The number of dimensions in a NumPy array is called its rank, which is the number of axes. A 1D array has rank 1, a 2D array has rank 2, and so on.

In NumPy, each linear array is called an axis, i.e., a dimension. For example, a 2D array can be seen as an array of 1D arrays.

So in NumPy, a one-dimensional direction is an axis. The first axis corresponds to the outer array, and the second axis corresponds to arrays inside it. The number of axes (rank) is the number of dimensions.

In many operations you can specify axis. axis=0 means operating along axis 0 (typically column-wise), while axis=1 means operating along axis 1 (typically row-wise).

Important ndarray attributes in NumPy arrays include:

• ndarray.ndim Rank, i.e., the number of axes or dimensions

  1
  import numpy as np
  2
  
  3
  a = np.arange(24)
  4
  print (a.ndim)             # a 现只有一个维度
  5
  # 现在调整其大小
  6
  b = a.reshape(2,4,3)  # b 现在拥有三个维度
  7
  print (b.ndim)

• ndarray.shape Array dimensions; for a matrix, n rows by m columns

  ndarray.shape can also be used to reshape an array.

  NumPy also provides the reshape function to resize/reshape arrays.

  1
  import numpy as np
  2
  
  3
  a = np.array([[1,2,3],[4,5,6]])
  4
  print (a.shape)
  5
  
  6
  a.shape =  (3,2)
  7
  print (a)
  8
  
  9
  a = np.array([[1,2,3],[4,5,6]])
  10
  b = a.reshape(3,2)
  11
  print (b)

• ndarray.size The total number of array elements, equivalent to n*m in .shape (for matrices)

• ndarray.dtype Element type of the ndarray object

• ndarray.itemsize Size of each element in the ndarray, in bytes

  1
  import numpy as np
  2
  
  3
  # 数组的 dtype 为 int8（一个字节）
  4
  x = np.array([1,2,3,4,5], dtype = np.int8)
  5
  print (x.itemsize)
  6
  
  7
  # 数组的 dtype 现在为 float64（八个字节）
  8
  y = np.array([1,2,3,4,5], dtype = np.float64)
  9
  print (y.itemsize)

• ndarray.flags Memory information of the ndarray object

  Property	Description
  C_CONTIGUOUS (C)	Data is stored in a single C-style contiguous segment
  F_CONTIGUOUS (F)	Data is stored in a single Fortran-style contiguous segment
  OWNDATA (O)	The array owns the memory it uses, or borrows it from another object
  WRITEABLE (W)	The data area is writable; if set to False, the data becomes read-only
  ALIGNED (A)	The data and all elements are properly aligned for hardware
  UPDATEIFCOPY (U)	This array is a copy of another array; when released, the original array content is updated

  1
  import numpy as np
  2
  
  3
  x = np.array([1,2,3,4,5])
  4
  print (x.flags)

• ndarray.real Real part of ndarray elements

• ndarray.imag Imaginary part of ndarray elements

• ndarray.data Buffer containing the actual array elements. Since elements are usually accessed via indexing, this attribute is not often used directly.

Creating NumPy Arrays#

Besides using the underlying ndarray constructor, NumPy arrays can also be created in the following ways.

• numpy.empty

  The numpy.empty method creates an uninitialized array with a specified shape and data type:

  1
  numpy.empty(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order  有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

  Usage:

  1
  import numpy as np
  2
  x = np.empty([3,2], dtype = int)
  3
  print (x)

• numpy.zeros

  Create an array of the specified size, filled with 0s:

  1
  numpy.zeros(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order  'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

  Usage:

  1
  import numpy as np
  2
  
  3
  # 默认为浮点数
  4
  x = np.zeros(5)
  5
  print(x)
  6
  
  7
  # 设置类型为整数
  8
  y = np.zeros((5,), dtype = int)
  9
  print(y)
  10
  
  11
  # 自定义类型
  12
  z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
  13
  print(z)

• numpy.ones

  Create an array of the specified shape, filled with 1s:

  1
  numpy.ones(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order    'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

  Usage:

  1
  import numpy as np
  2
  
  3
  # 默认为浮点数
  4
  x = np.ones(5)
  5
  print(x)
  6
  
  7
  # 自定义类型
  8
  x = np.ones([2,2], dtype = int)
  9
  print(x)

• numpy.zeros_like/ones_like

  numpy.zeros_like creates an array with the same shape as a given array, filled with 0s.

  Both numpy.zeros and numpy.zeros_like are used to create arrays whose elements are all 0.

  The difference is that numpy.zeros directly specifies the shape to create, while numpy.zeros_like creates an array with the same shape as an existing array.

  1
  numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
  2
  
  3
  # a  给定要创建相同形状的数组
  4
  # dtype  创建的数组的数据类型
  5
  # order  数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）
  6
  # subok  是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组
  7
  # shape  创建的数组的形状，如果不指定，则默认为 a 数组的形状。

  Usage:

  1
  import numpy as np
  2
  
  3
  # 创建一个 3x3 的二维数组
  4
  arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
  5
  
  6
  # 创建一个与 arr 形状相同的，所有元素都为 0 的数组
  7
  zeros_arr = np.zeros_like(arr)
  8
  print(zeros_arr)

Array Slicing and Indexing#

1
import numpy as np
2

3
a = np.arange(10)
4
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
5
print (a[s])
6

7
# 也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作
8
a = np.arange(10)
9
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
10
print(b)
11

12
a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
13
b = a[5]
14
print(b)
15

16
print(a[2:])
17

18
print(a[2:5])
19

20
# 多维
21
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
22
print(a)
23
# 从某个索引处开始切割
24
print('从数组索引 a[1:] 处开始切割')
25
print(a[1:])
26

27
# 省略号
28
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
29
print (a[...,1])   # 第2列元素
30
print (a[1,...])   # 第2行元素
31
print (a[...,1:])  # 第2列及剩下的所有元素

Advanced Indexing#

NumPy provides more indexing methods than ordinary Python sequences.

In addition to integer and slice indexing, arrays can also be indexed with integer arrays, boolean indexing, and fancy indexing.

Advanced indexing in NumPy refers to using integer arrays, boolean arrays, or other sequences to access array elements. Compared with basic indexing, advanced indexing can access arbitrary elements and is useful for more complex operations and modifications.

1
import numpy as np
2

3
# 获取数组中 (0,0)，(1,1) 和 (2,0) 位置处的元素
4
x = np.array([[1,  2],  [3,  4],  [5,  6]])
5
y = x[[0,1,2],  [0,1,0]]
6
print (y)
7

8
# 获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]
9
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])
10
print ('我们的数组是：' )
11
print (x)
12
print ('\\n')
13
rows = np.array([[0,0],[3,3]])
14
cols = np.array([[0,2],[0,2]])
15
y = x[rows,cols]
16
print  ('这个数组的四个角元素是：')
17
print (y)
18

19
# 可以借助切片 : 或 … 与索引数组组合
20
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
21
b = a[1:3, 1:3]
22
c = a[1:3,[1,2]]
23
d = a[...,1:]
24
print(b)
25
print(c)
26
print(d)

1
import numpy as np
2

3
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])
4
print ('我们的数组是：')
5
print (x)
6
print ('\\n')
7
# 现在我们会打印出大于 5 的元素
8
print  ('大于 5 的元素是：')
9
print (x[x >  5])
10

11
a = np.array([np.nan,  1,2,np.nan,3,4,5])
12
print (a[~np.isnan(a)])
13

14
a = np.array([1,  2+6j,  5,  3.5+5j])
15
print (a[np.iscomplex(a)])