Python科学计算库 — NumPy 基本方法

一、NumPy 简介

• Numpy 是以矩阵为基础的数学计算模块，NumPy 模块是Python的一种开源的数值计算扩展，是一个用Python实现的科学计算包，主要包括：

  （1）一个具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组，称为ndarray(N-dimensional array object)

  （2）用于对整组数据进行快速运算的标准数学函数：ufunc(universal function object)

  （3）实用的线性代数、傅里叶变换和随机数生成函数。

  （4）NumPy和稀疏矩阵的运算包Scipy配合使用更加方便。

• ndarray：NumPy 核心数据结构，通常被称作数组。注意：numpy.array 和标准Python库类 array.array 不同，后者只处理一维数组和提供少量功能。
• 导入NumPy 模块：

  import numpy as np

二、创建Ndarray

通过NumPy 模块中的常用函数创建ndarray 多维数组对象，主要函数有：array(), zeros(), ones(), empty()；

通过其它一些函数创建，如：arange(), linspace(), logspace(), random().

1、array()

函数原型：

array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

返回值：指定序列的数组

参数：

• object

  ：传入一个序列，列表、元组或字典类型。

• dtype=None

  ：数组元素的数据类型，默认为None，表示数据类型由传递的object 确定。

• copy=True

  ：是否复制一份object 数据。默认为True，表示对原object 复制一份副本，array 方法对副本进行操作；如果为False，可能会改变原数据。

  list01 = [2, 3, 5, 8, 6] 
  np.array(list01)         #创建一维数组
  list02 = [[2,3], [5,4],[8,3]]
  np.array(list02)         #创建二维数组
  t = ("数学", "英语", "语文")
  np.array(t)         #通过元组创建数组
  dic01 = {"数学":98, "英语":95}
  np.array(dic01)     #通过字典创建数组
             

  输出结果：

  array([2, 3, 5, 8, 6])

  array([[2, 3],

  [5, 4]])

  array([‘数学’, ‘英语’, ‘语文’], dtype=’<U2’)

  array({‘数学’: 98, ‘英语’: 95}, dtype=object)

2、zeros()

函数原型：

zeros(shape, dtype=None, order='C')

返回值：指定形状的全0数组

• shape

  ：指定数组的形状(维度)。参数值为int 表示一维数组的长度；为tuple 表示多维数组的形状，如(3, 4) 表示3*4，3行4列。

• dtype=None

  ：数组元素的数据类型，

np.zeros(5)        #一维
np.zeros((2, 3))   #二维: 形状参数用元组表示
           

输出结果：

array([0., 0., 0., 0., 0.])

array([[0., 0., 0.],

[0., 0., 0.]])

3、ones()

函数原型：

ones(shape, dtype=None, order='C')

返回值：指定形状的全1数组

参数：同 np.zeros()

np.ones(5)
np.ones((2,3))
           

4、empty()

函数原型：

empty(shape, dtype=None, order='C')

返回值：一个没有具体值的数组，即未初始化的数组，数组值为垃圾数字。该方法不常用。

参数：同np.zeros()

5、arange()

函数原型：

arange(start=None, stop=None, step=None, dtype=None)

返回值：等差数列组成的一维数组

参数：

• start=None

  ：初值，默认为0

• stop=None

  ：终值，默认为无穷大

• step=None

  ：步长，即等差数列的公差，默认为1

  注意：Python 中的区间一般都是前闭后开，即初值能取到，终值取不到。

  np.arange(5)
  np.arange(1, 10, 2)
             

  输出结果：

  array([0, 1, 2, 3, 4])

  array([1, 3, 5, 7, 9])

6、linspace()

函数原型：

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

返回值：指定数据范围和元素个数的等差数列构成的一维数组

参数：

• start

  ：初值

• stop

  ：终值

• num

  ：指定范围内的元素个数

• endpoint=True

  ：是否包含终值，默认为True，表示包含。

• retstep=False

  ：是否返回步长，默认为False，表示不返回。

注意：linspace() 必须指定数据范围(初值和终值)，不同于arange()方法。

np.linspace(1, 7, 3, endpoint=False)
np.linspace(1, 9, 3, retstep=True)
           

输出结果：

array([1., 3., 5.])

(array([1., 5., 9.]), 4.0)

7、logspace()

函数原型：

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

返回值：指定范围内和元素个数的等比数列组成的一维数组

参数：

• start

  ：初值的指数项，如3 表示base的3次方

• stop

  ：终值的指数项

• num=50

  ：指定范围内数组的元素个数，默认为50

• endpoint=True

  ：是否包含终值，默认包含

• base=10.0

  ：底数，默认为10

np.logspace(2, 5, 4, base=2.0)   
# 以2 为底数，2的平方为初值，2的5次方为终值，生成4个元素组成的等比数列
np.logspace(1, 5, 3)  #10E1 到10E5 之间生成3个元素，构成等比数列
           

输出结果：

array([ 4., 8., 16., 32.])

array([1.e+01, 1.e+03, 1.e+05])

8、random 模块的相关方法

np.random.random(5)            #生成5个 0-1 的随机数组成的一维数组
np.random.random((3, 4))       #生成 0-1 随机数组成3行4列的二维数组
np.random.rand(8)        #生成8个符合平均分布的 0-1 的随机数组成的一维数组
np.random.rand(3, 4)     #生成符合0-1 随机分布的3*4 的二维数组
np.random.randn(10)           #生成10个符合正态分布的样本
np.random.randn(10, 2)        #生成10个符合正态分布的2维数据样本
np.random.randint(1, 5, 10)        #生成10个1-5之间的随机整数
np.random.randint(1, 5, (3, 4))    #生成1-5 之间的随机整数组成的3*4 的二维数组
           

三、NumPy 对象属性

属性	含义
ndim	数组轴(维度)的个数，轴的个数叫做秩
shape	数组的维度(形状)，
size	数组元素的总个数
dtype	数组元素的数据类型，可以通过指定dtype 使用标准Python 类型，不过NumPy提供它自己的数据类型
itemsize	数组元素的大小，每个元素的字节数

arr = np.array([[2,3, 5], [5,3, 4]])
print("维度的数量：", arr.ndim)
print("数组的形状：", arr.shape)
print("数组的元素类型：", arr.dtype)
print("数组元素的数量：", arr.size)
print("数组元素的大小：", arr.itemsize)
           

输出结果：

维度的数量： 2

数组的形状： (2, 3)

数组的元素类型： int32

数组元素的数量： 6

数组元素的大小： 4

1、数据类型

• 创建numpy数组时可通过属性dtype 显式指定数据类型，如果不指定，numpy 会自动推断出适合的数据类型，一般不需要显式给定数据类型。
• astype() 方法修改数组元素的数据类型。

Example：显式指定、修改数组元素的数据类型

arr01 = np.array([1.8, 5.24, 3.21], dtype=np.int32)
arr02 = np.array([2, 5, 8], dtype=np.float32)
arr03 = np.array([1.32, 2.5, 4.16])
print("arr03 元素数据类型：", arr03.dtype)
arr04 = arr03.astype(np.int32)   # 修改arr03 数据类型为int32，可直接传入参数 int
print("arr04 元素数据类型：", arr04.dtype)
           

输出结果：

array([1, 5, 3])

array([2., 5., 8.], dtype=float32)

arr03 元素数据类型： float64

arr04 元素数据类型： int32

NumPy 基本数据类型

数据类型	类型简写	说明
int_	默认整型
intc	等价于long 的整型
int8	i1	字节整型，1个字节，范围：[-128, 127]
int16	i2	整型，2个字节，范围：[-32768, 32767]
int32	i3	整型，4个字节，范围：[-2^31, 2^31-1]
int64	i4	整型，8个字节，范围：[-2^63, 2^63-1]
uint8	u1	无符号整型，1个字节，范围：[0, 255]
uint16	u2	无符号整型，2个字节，范围：[0, 65535]
uint32	u3	无符号整型，4个字节，范围：[0, 2^32-1]
uint64	u4	无符号整型，8个字节，范围：[0, 2^64-1]
bool_	以一个字节形成存储的布尔值，True 或 False
float_	float64 简写形式
float16	F2	半精度浮点型(2字节)：1符号位+5位指数+10位的小数部分
float32	f4或者f	单精度浮点型(4字节)：1符号位+8位指数+23位的小数部分
float64	f8或者d	双精度浮点型(8字节)：1符号位+11位指数+52位的小数部分
complex_	c16	complex128 的简写形式
complex64	c8	复数，由两个32位的浮点数来表示
complex128	c16	复数，由两个64位的浮点数来表示
object	O	Python对象类型
String_	S	固定长度的字符串类型(每个字符1个字节)，比如：要创建一个长 度为8的字符串，应该使用S8
Unicode_	U	固定长度的unicode类型的字符串(每个字符占用字节数由平台决 定)，长度定义类似String_类型

2、ndarray 修改形状

• 直接修改数组对象的shape 属性值（int或元组类型），要求修改前后数组的size 不变。
• 通过数组对象的reshape() 方法返回一个指定shape的新数组，原数组形状不变，但是新数组和原数组共享同一个内存空间，也就是修改任何一个数组中的值都会对另外一 个产生影响，要求新数组的元素个数和原数组一致（此方法还可以进行降维操作）。

注：修改数组形状时应保持数组的size 值不变，即数组元素的个数不变；

当指定某一个轴为-1的时候，表示将根据数组元素的数量自动计算该轴的 长度值。

arr = np.array([[1, 3, 5, 7, 9, 1], [2, 4, 6, 8, 10, 12]])  #创建一个2*6的二维数组
print("原数组维度：", arr.shape)
# 1. 修改数组的shape值
arr.shape = (3, 4)    
print("修改之后数组维度：", arr.shape)
# 2. 通过reshape方法修改形状为4*3
arr02 = arr.reshape(4, 3)    # 返回一个4*3的二维数组
print("reshape 返回的数组维度：", arr02.shape)
print("原数组维度：", arr.shape)
arr03 = arr.reshape(6, -1)   # 返回一个6行的数组，-1 表示列数自动计算
arr04 = arr.reshape(12)      # 降维：返回一个一维数组
print("arr03 的维度：", arr03.shape)
print("arr04：", arr04)
           

输出结果：

原数组维度： (2, 6)

修改之后数组维度： (3, 4)

reshape 返回的数组维度： (4, 3)

原数组维度： (3, 4)

arr03 的维度： (6, 2)

arr04： [ 1 3 5 7 9 1 2 4 6 8 10 12]

四、Numpy 基本操作

1、数组与标量、数组之间的运算

arr01 = np.array([1, 2, 3, 4, 5])
arr02 = np.array([3, 4, 5, 6, 7])
# 1、数组与标量的运算: 标量与每个数组元素都进行运算
print("数组与标量运算：", arr01 + 10)  
# 2、数组之间的运算：元素级运算,相同位置的元素进行运算。要求数组形状相同
print("数组与数组运算：", arr01 + arr02)
# 3、广播：多维数组与一维数组之间的运算  形状：维度要么相同，要么为1
# 一维数组为行向量：行向量与多维数组的每一行运算
# 一维数组为列向量：列向量与多维数组的每一列运算
row = np.array([1,2,3])   # 行向量：1行3列
column = np.array([[5],[6]])   #列向量：2行1列
arr03 = np.array([[2, 5, 3], [4, 8, 6]])  # 2*3的二维数组
print("广播-行运算：\n", arr03 + row)
print("广播-列运算：\n", arr03 + column)
           

输出结果：

数组与标量运算： [11 12 13 14 15]

数组与数组运算： [ 4 6 8 10 12]

广播-行运算：

[[ 3 7 6]

[ 5 10 9]]

广播-列运算：

[[ 7 10 8]

[10 14 12]]

广播：行向量的每一行与数组的每一行进行运算，或列向量的每一行与数组的每一列进行运算。

2、数组的矩阵积(matric product)

两个数组求矩阵积要求：前数组的行数 = 后数组的列数， 同矩阵乘法。

# np.dot(arr1, arr2) 前数组的行数 = 后数组的列数，条件同矩阵乘法
arr1 = np.array([[2, 3], [1, 5], [8, 2]])  # 3行2列：3*2
arr2 = np.array([[1, 3, 2, 5], [4, 2, 1, 2]])  #2行4列：2*4
print(np.dot(arr1, arr2))
           

输出结果：

[[14 12 7 16]

[21 13 7 15]

[16 28 18 44]]

3、数组的索引与切片

arr = np.array([[[1,2,3,4],[5,6,7,8],[9,10,11,12]],[[21,22,23,24],[25,26,27,28],[29,30,31,32]]])
arr       # 三维数组shape：2*3*4， 2块，3行，4列
# 1、索引：获取指定位置的元素
print("获取第0块，第2行，第3列的元素：", arr[0, 2, 3])
# 2、切片：切片操作获取的是原数组的视图，对新数组进行操作会影响原数组，即浅拷贝！
print("获取第0块，第1行，第2到4列的数据", arr[0, 1, 2:5]) 
# 3、花式索引：获取多行或多列数据
# 通过花式索引获取的新数组是一个副本，修改新数组不会影响原数组，相当于深拷贝！
# 数组名[行索引，列索引]  中括号内从左到右依次是：行索引，列索引；或：块索引，行索引，列索引 
print("获取第0块，第1行，第1列和第3列的数据：", arr[0, 1, [1,3]])  
print("获取第1块，第2行，第1列到第3列的数据：", arr[1, 2, 1:]) 
print("获取第1块，所有行，第2列的数据：", arr[1, :, 2]) 
print("获取所有块，第0，2行的所有列的数据：\n", arr[:, [0,2], :])
           

输出结果：

array([[[ 1, 2, 3, 4],

[ 5, 6, 7, 8],

[ 9, 10, 11, 12]],

[[21, 22, 23, 24],

[25, 26, 27, 28],

[29, 30, 31, 32]]])

获取第0块，第2行，第3列的元素： 12

获取第0块，第1行，第2到4列的数据 [7 8]

获取第0块，第1行，第1列和第3列的数据： [6 8]

获取第1块，第2行，第1列到第3列的数据： [30 31 32]

获取第1块，所有行，第2列的数据： [23 27 31]

获取所有块，第0，2行的所有列的数据：

[[[ 1 2 3 4]

[ 9 10 11 12]]

[[21 22 23 24]

[29 30 31 32]]]

# 4、索引器：取多行多列的数据
print("获取所有块的第0，2行的第0，1，3列的6个数据：\n", arr[np.ix_([0,1], [0,2],[0,1,3])])

# 5、布尔索引：arr[condition] 返回condition中为True 的位置对应的元素组成的数组
score = np.array([82, 78, 93, 100, 75])
condition = score>=80       #数组与元素比较时，返回的是一个布尔类型数组
print("获取>=80的成绩：", score[condition])
names = np.array( ['Tom', 'Arthur', 'Selina'])
scores = np.array([[98,95,89], [88,85,80], [100, 99, 95]])
classes = np.array(['语文', '数学', '英语'])
print("获取Arthur的分数：", scores[(names == 'Arthur')])
print("获取Selina的数学分数：", scores[names == 'Selina', classes == '数学'])
           

输出结果：

获取所有块的第0，2行的第0，1，3列的6个数据：

[[[ 1 2 4]

[ 9 10 12]]

[[21 22 24]

[29 30 32]]]

获取>=80的成绩： [ 82 93 100]

获取Arthur的分数： [[88 85 80]]

获取Selina的数学分数： [99]

4、数组的转置与轴对换

# 1、通过T 属性进行转置
arr1 = np.array([[1,2,3], [4,5,6]])  # 2*3 的数组
print("数组维度为：", arr1.shape)
print("转置后的数组维度为：", arr1.T.shape)

# 2、通过transpose()方法可以转置；多维数组可以将任意轴进行对换，(2,0,1)
arr2 = np.array([[[1,2,3,4],[5,6,7,8],[9,10,11,12]],[[21,22,23,24],[25,26,27,28],[29,30,31,32]]]) # 数组维度：2*3*4
arr3 = arr2.transpose(2, 0, 1)   # 原始数组轴的顺序：0，1，2；对换后的轴顺序：2，0，1
print("原始数组的维度为：", arr2.shape)
print("轴对换后数组的维度为：", arr3.shape)
print("通过T属性转置后的维度为：", arr2.T.shape)
           

输出结果：

数组维度为： (2, 3)

转置后的数组维度为： (3, 2)

原始数组的维度为： (2, 3, 4)

轴对换后数组的维度为： (4, 2, 3)

通过T属性转置后的维度为： (4, 3, 2)

5、数组的拉伸与合并

• np.tile(A, rep) ： 将数组A 进行拉伸，沿着A 的维度重复rep次。

# 拉伸：np.tile(arr, rep) 将数组arr 拉伸为原来的rep 倍
# rep为int，表示横向拉伸倍数；rep 为列表[m, n]，表示纵向拉伸为m 倍，横向拉伸为n倍
# np.tile(arr,[m,n])  m为数组纵向拉伸倍数，n为横向拉伸的倍数
arr = np.array([[1,2,3], [4,5,6]])
print("原始数组为：\n", arr)
arr2 = np.tile(arr, [3, 2])
print("拉伸后的数组为：\n", arr2)
           

输出结果：

原始数组为：

[[1 2 3]

[4 5 6]]

拉伸后的数组为：

[[1 2 3 1 2 3]

[4 5 6 4 5 6]

[1 2 3 1 2 3]

[4 5 6 4 5 6]

[1 2 3 1 2 3]

[4 5 6 4 5 6]]

• 合并：将数组合并的方法主要有3种。

  np.stack((arr1, arr2), axis=0)

  ：取出两数组的每一行作为一个元素进行合并。

  np.hstack()

  ：横向合并

  np.vstack()

  ：纵向合并

# 合并：stack(), hstack(), vstack()
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
np.stack((a,b))  
#等价于：np.stack((a,b), axis=0)   取出两数组的每一行作为一个元素进行合并，直接在最外面套个大盒子
np.stack([a,b], 1)     #取出两数组的每一列作为一个元素进行合并

arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.array([[11,12,13],[14,15,16]])
np.hstack((a,b))    # hstack：依次取出每个数组的第一行、第二行，构成新数组的第一行、第二行
np.vstack((a,b))    # vstack：依次取出每个数组的第一列、第二列，构成新数组的第一列、第二列
np.hstack((arr1, arr2))
np.vstack((arr1, arr2))

           

输出结果：

array([[ 1, 2, 3, 4],

[10, 20, 30, 40]])

array([[ 1, 10],

[ 2, 20],

[ 3, 30],

[ 4, 40]])

array([ 1, 2, 3, 4, 10, 20, 30, 40])

array([[ 1, 2, 3, 4],

[10, 20, 30, 40]])

array([[ 1, 2, 3, 11, 12, 13],

[ 4, 5, 6, 14, 15, 16]])

array([[ 1, 2, 3],

[ 4, 5, 6],

[11, 12, 13],

[14, 15, 16]])

更多关于stack(), hstack(), vstack() 的用法和区别，请参考：

https://blog.csdn.net/qq_39521554/article/details/80469666

五、ndarray 通用函数/常用函数

一元函数

函数名	调用方法	描述
abs, fabs	np.fabs(arr)	计算整数、浮点数或者复数的绝对值。对于非复数，一般使用更快的fabs
sqrt	np.sqrt(arr)	计算各个元素的平方根，相当于arr ** 0.5， 要求arr的每个元素必须是非负数
square	np.square(arr)	计算各个元素的平方，相当于arr**2
exp	np.exp(arr)	计算各个元素的指数e的x次方
log、log10、log2、log1p	np.log(arr) np.log10(arr) np.log2(arr) np.log1p(arr)	分别计算自然对数、底数为10的log、底数为2的log以及log(1+x)要求arr中的每个元素必须为正数
sign	np.sign(arr)	计算各个元素的正负号: 1 正数，0：零，-1：负数
ceil	np.ceil(arr)	计算各个元素的ceiling值，即大于等于该值的最小整数
floor	np.floor(arr)	计算各个元素的floor值，即小于等于该值的最大整数
rint	np.rint(arr)	将各个元素值四舍五入到最接近的整数，保留dtype的类型
modf	np.modf(arr)	将数组中元素的小数位和整数位以两部分独立数组的形式返回
isnan	np.isnan(arr)	返回一个表示“哪些值是NaN(不是一个数字)”的布尔类型数组
isfinite、isinf	np.isfinite(arr)、isinf(arr)	分别返回表示”哪些元素是有穷的(非inf、非NaN)”或者“哪些元素是无穷的”的布尔型数组
cos、cosh、sin、sinh、tan、tanh	np.cos(arr)、np.sinh(arr)	普通及双曲型三角函数
arccos、arccosh、arcsin、arcsinh、 arctan、arctanh	np.arctan(arr)	反三角函数

Example - Jupyter代码：

# 绝对值函数：abs，fabs(非复数的绝对值)
arr01 = np.array([-8, 4, -5, 6])
np.fabs(arr01)

# 平方根：sqrt()
np.sqrt(arr01)   #负数的平方根为nan 

# 平方运算：square()
np.square(arr01)

# 计算各元素的指数e的x次方
arr02 = np.array([1,2,3])
np.exp(arr02)

# 对数：log，log2，log10 分别是求底数为e，2，10 的对数
arr03 = np.array([2, 2.718, 4, 5, 10, 25, 100 ])
print("底数为e的对数：", np.log(arr03).round(3))   # arr.round(3) 表示四舍五入保留3位小数
print("底数为2的对数：", np.log2(arr03).round(3))
print("底数为10的对数：", np.log10(arr03).round(3))
# 随机底数用换底公式，如求以5为底的对数：换底公式 -- np.log2(arr)/np.log2(5)
print("底数为5的对数：", (np.log2(arr03)/np.log2(5)).round(3))
           

输出结果：

array([8., 4., 5., 6.])

array([ nan, 2. , nan, 2.44948974])

array([64, 16, 25, 36], dtype=int32)

array([ 2.71828183, 7.3890561 , 20.08553692])

底数为e的对数： [0.693 1. 1.386 1.609 2.303 3.219 4.605]

底数为2的对数： [1. 1.443 2. 2.322 3.322 4.644 6.644]

底数为10的对数： [0.301 0.434 0.602 0.699 1. 1.398 2. ]

底数为5的对数： [0.431 0.621 0.861 1. 1.431 2. 2.861]

# 取整  ceil：向上取整； floor：向下取整
arr = np.array([2.346, 3.652, 5.849, 8.192])
print("向上取整：", np.ceil(arr))
print("向下取整：", np.floor(arr))

# rint：四舍五入取整；round(arr, n)：四舍五入保留n 位小数
print("四舍五入取整：", np.rint(arr))
print("四舍五入保留2位小数：", np.round(arr, 2))
           

输出结果：

向上取整： [3. 4. 6. 9.]

向下取整： [2. 3. 5. 8.]

四舍五入取整： [2. 4. 6. 8.]

四舍五入保留2位小数： [2.35 3.65 5.85 8.19]

# isnan(): 判断数组元素是否为nan 类型，返回一个布尔类型数组
arr = np.array([2, 5, np.nan, 8, np.nan, np.Infinity])
np.isnan(arr)
# 过滤掉nan 类型的数据：condition为 isnan()的返回值取反 
arr[~np.isnan(arr)]  

# isfinite(): 判断元素是否是有穷的(非inf，非nan)
# isinf()：判断元素是否是无穷的   返回布尔类型的数组
np.isfinite(arr)
np.isinf(arr)
           

输出结果：

array([False, False, True, False, True, False])

array([ 2., 5., 8., inf])

array([ True, True, False, True, False, False])

array([False, False, False, False, False, True])

二元函数

常用的二元函数主要有：取模，点积，比较大小，逻辑与/或/异或，指数运算。

函数名	调用方法	描述
mod	np.mod(arr1, arr2)	元素级的取模计算（除法取余）
dot	np.dot(arr1, arr2)	求两个数组的点积
greater、greater_equal、less、less_equal、equal、not_equal	np.greater(arr1, arr2) np.less(arr1, arr2) np.equal(arr1, arr2)	执行元素级的比较运算，返回一个布尔型数组。greater：大于，less：小于，equal：等于
logical_and、logical_or、logical_xor	np.logical_and(arr1,arr2) np.logical_or(arr1,arr2) np.logical_xor(arr1,arr2)	执行元素级的布尔逻辑运算，相当于中缀运算符&、^ 、| （与，或，异或）
power	np.power(arr, 3)	求解对数组中的每个元素进行给定次数的指数值，类似于: arr ** 3

# 取余操作：mod(num, mod)  num为被除数，mod 为除数 (num 和 mod 可以是一个数或数组)
arr01 = np.array([7, 12, 25, 18])
arr02 = np.array([3, 8, 10, 12])
print("数组arr01 对数组arr02 取模：", np.mod(arr01, arr02))
print("数组arr01 对数字8 取模：", np.mod(arr01, 8))

# 点积：矩阵的数量积 dot(arr1, arr2)
print(np.dot(arr01, arr02))     # 等于7*3+12*8+25*10+18*12

# power(x, m): 求指数，x的m次方
np.power(arr01, 2)
           

输出结果：

数组arr01 对数组arr02 取模： [1 4 5 6]

数组arr01 对数字8 取模： [7 4 1 2]

583

array([ 49, 144, 625, 324], dtype=int32)

# 比较大小：greater/equal/less
arr1 = np.array([7, 12, 25, 18, 16])
arr2 = np.array([13, 8, 30, 18, 15])
print("arr1是否大于arr2：", np.greater(arr1, arr2))  #大于：若arr1>arr2, 则返回True；否则返回False
print("arr1是否等于arr2：", np.equal(arr1, arr2))
print("arr1是否小于等于arr2：", np.less_equal(arr1, arr2))

# 逻辑运算：与/或/异或  
# logical_and(arr1, arr2)：&
# logical_or(arr1, arr2)：|
# logical_xor(arr1, arr2)：^
arr = np.array([21, 70, 45, 9, 62, 49, 71, 13, 50, 80])
condition = np.logical_and(arr>=60, arr<=80)
print(condition)
arr[condition]
           

输出结果：

arr1是否大于arr2： [False True False False True]

arr1是否等于arr2： [False False False True False]

arr1是否小于等于arr2： [ True False True True False]

[False True False False True False True False False True]

array([70, 62, 71, 80])

六、聚合函数

聚合函数是对一组（eg一个数组）进行操作，返回一个单一值作为结果的函数。 聚合函数也可以指定对某个具体的轴进行数据聚合操作；常见的聚合操作有： 平均值、最大值、最小值、总体标准偏差等。

• 最大值：

  np.amax(arr)

  ; 等价于

  arr.max()

• 最小值：

  np.amin(arr)

  ; 等价于

  arr.min()

• 平均值：

  np.mean(arr)

  ; 等价于

  arr.mean()

• 标准差：

  np.std(arr)

  ; 等价于

  arr.std()

• 方差：

  np.var(arr)

  ; 公式：np.mean((arr - arr.mean())**2)

arr = np.array([[23, 12, 35], [19, 26, 8]])
print("每一列的最大值：", np.amax(arr, axis=0))  #axis=0：求每一列 的最大值
print("每一行的最小值：", np.amin(arr, axis=1))  #axis=1：求每一行 的最小值
print("数组的最大值：", arr.max())     #求数组的最大值
print("数组的最大值：", arr.min())     #求数组的最小值
print("每一行的平均值：", np.mean(arr, axis=1).round(3))  #求每一行的平均值
print("数组的标准差：", np.std(arr).round(3))  #求数组的标准差
print("数组的标准差：", arr.std().round(3))    
print("数组的方差：",np.var(arr).round(3))
           

输出结果：

每一列的最大值： [23 26 35]

每一行的最小值： [12 8]

数组的最大值： 35

数组的最大值： 8

每一行的平均值： [23.333 17.667]

数组的标准差： 8.921

数组的标准差： 8.921

数组的方差： 79.583

七、np.where函数

• 三元表达式：

  x if condition else y

  : condition为真返回x，否则返回y。

• np.where(condition, x, y)

  ：condition为True返回x，否则返回y。
• 三元表达式可用列表递推式表达：

  arr = [x if c else y for x,y,c in zip(arr1, arr2, condition)]
  #zip函数: 依次从arr1,arr2,condition 数组中取值按顺序赋给x,y,c
             

  等价于：

  np.where(condition, arr1, arr2)  
  #where函数：condition为True则返回arr1，否则返回arr2
             

  Example：

  arr1 = np.random.randint(1,20, (2,5))
  arr2 = np.random.randint(1,20, (2,5))
  print("arr1：\n", arr1)
  print("arr2：\n", arr2)
  cond = arr1>arr2
  np.where(cond, arr1, arr2)  #返回两数组对应位置较大的数
             

  输出结果：

  arr1：

  [[14 15 1 15 18]

  [ 1 8 16 10 4]]

  arr2：

  [[ 4 13 1 15 11]

  [ 7 8 13 4 18]]

  array([[14, 15, 1, 15, 18],

  [ 7, 8, 16, 10, 18]])

八、np.unique函数

np.unique(arr)

：去重+排序，只保留不重复的数据。

arr = np.array([2, 6, 4, 2, 5, 8, 3, 6, 5])
np.unique(arr)
           

输出结果：

array([2, 3, 4, 5, 6, 8])

*以上是Numpy 的基本属性及常用方法，更多相关知识请参考：

1、NumPy官网：http://www.numpy.org/

2、官方文档：https://docs.scipy.org/doc/numpy/user/index.html