【AI_常用Python库】Numpy库

这一篇博文是【 AI学习路线图】系列文章的其中一篇，点击查看目录：AI学习完整路线图

1.简介

Numpy是Numerical Python的简称，即数值Python包，是Python进行科学计算的一个基础包，主要包括：
- 一个具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组，称为ndarray。
- 用于对整数数据进行快速运算的标准数学函数ufunc。
- 实用的线性代数、傅里叶变换、随机数生成函数
- Numpy和稀疏矩阵运算包Scrpy配合使用更方便

2.ndarray

ndarry（N-dimensional array）是N维数组，是numpy中的核心数据结构，是一种由相同类型的元素组成的多维数组，元素的个数是事先定好的，元素的类型由dtype对象指定。

2.1创建ndarray

import numpy as np

print("------第一种创建方式：array-----------")
#接收一个普通的序列，将其转换为ndarray
# 第一种创建方式：array
a = np.array([
    [1, 2, 3], [4, 5, 6]
], dtype=np.float)

print(a)
print(type(a))
# 打印元素的数据类型
print(a.dtype)

# 传递一个元组创建
b = np.array((1, 2, 3, 4))
print(b)
#默认元素是浮点数
print(b.dtype)

print("----------第二种方式创建：zeros，用0填充------------")
#创建指定长度、或者指定形状的全零数组
# 第二种方式创建：zeros
# 用0填充，生成一个一维的数组,3个元素
a2 = np.zeros(3)
# 用0填充，生成一个三维的数组，一维有2个元素、二维有3个元素，三维有4个元素
b2 = np.zeros((2,3,4))
print(a2)
print(b2)
print(b2.dtype)

print("----------第三种方式创建：ones，用1填充------------")
#创建指定长度或者指定形状的全1数组。
#用1填充创建数组
c2=np.ones((2,3,4))
print(c2)


print("----------第四种方式创建：用随机数/空值填充------------")
#创建一个没有任何具体值的数组，具体来说是创建一些未初始化的ndarray多维数组。
a3=np.empty((2,3,4))
print(a3)

2.2 其他创建ndarray方法

print("----------第五种方式创建：arange函数------------")
#创建ndarrary，从1开始，到10（不包括10），步长为2
#类似于Python里的range函数，通过指定开始值、结束值、步长来创建一维数组
a4=np.arange(1,10,2)
print(a4)

print("----------第六种方式创建：linspace函数（等差数列）------------")
#创建ndarrary，指定开始值、结束值和元素个数来创建一个一维数组，数组的元素符合等差数列，
#可以通过endpoint关键字指定是否包含结束值，默认是包含结束值的
a5=np.linspace(1,9,3)
print(a5)
#当endpoint是False时，相当于个数加一（这个例子中是4个时）后去掉最后一个。
b5=np.linspace(1,9,3,endpoint=False)
print(b5)
c5=np.linspace(1,9,4,endpoint=True)
print(c5)
# 输出为：
# ---------第六种方式创建：linspace函数------------
# [ 1.  5.  9.]
# [ 1.          3.66666667  6.33333333]
# [ 1.          3.66666667  6.33333333  9.        ]

print("----------第六种方式创建：logspace函数(等比数列）------------")
#下面这个例子，是默认log以10为底，10的1次幂为开始，10的2次幂为结束（包含结束），这段区间内，取4个值，这4个值等比
#第二个是第一个的n倍，第三个是第二个的n倍.....
a6=np.logspace(0,2,4)
print(a6)
#指定log的底为2，从2的0次幂到2的4次幂之间，选择5个值，这5个值等比
b6=np.logspace(0,4,5,base=2)
print(b6)
#指定不包含结束，相当于个数值4加一，算出包含的值来，然后去掉最后一个
c6=np.logspace(0,4,4,base=2,endpoint=False)
print(c6)

print("----------第七种方式创建：随机数------------")
#由随机数生成指定形状的数组，这个例子是生成一个三维数组
a7=np.random.random((3,2,4))
print(a7)
#由10到20之间的值（不包括20），随机生成一个形状为(3,2,4)的三维数组
b7=np.random.randint(10,20,(3,2,4))
print(b7)

3 NumPy的数据类型

3.1 基本数据类型

数据类型	类型简写	说明
int_		整形
intc		等价于long的整形
int8	i1	1个字节，范围[-128,127]
int16	i2	2个字节，范围[-215 , 215 -1]
int32	i3	4个字节，范围[-231 , 231 -1]
int64	i4	8个字节，范围[-263 , 263 -1]
uint8	u1	无符号整形，1个字节，范围[0, 28]
uint16	u2	无符号整形，2个字节，范围[0 , 216 -1]
uint32	u3	无符号整形，4个字节，范围[0 , 232 -1]
uint64	u4	无符号整形，8个字节，范围[0 , 264 -1]
bool_		以一个字节存储布尔值
float_		float64简写形式
float16	f2	半精度浮点型（2个字节）
float32	f4或者f	单精度浮点型，4个字节
float64	f8或者d	双精度浮点型,8个字节
complex_	c16	complex128的简写形式
complex64	c8	复数，由两个32位的浮点数表示
complex128	c16	复数，由两个64位的浮点数来表示
object	O	Python对象类型
String_	S	固定长度的字符串类型（每个字符一个字节），如：要创建长度为8的字符串，应该使用S8
Unicode_	U	固定长度的unicode类型字符串（每个字符占用的字节数由平台决定）

3.2 ndarray修改形状

print("-------------修改形状第一种方式：修改shape的值")
#使用修改shape值的方式修改形状，会将原来的值改变
#定义一个4*5的矩阵
arr1=np.random.random((4,5))
print(arr1)
print("修改形状后：")
#把形状修改为2*10
arr1.shape=(2,10)
print(arr1)


print("-------------修改形状第二种方式：使用reshape方法")
#使用reshape修改形状后，不会对原来的数据进行修改
arr1=np.random.random((4,5))
#-1是维度自动计算
arr2=arr1.reshape(-1,4)
print(arr1)
print("-------")
print(arr2)

输出结果：
-------------修改形状第一种方式：修改shape的值
[[ 0.19856203  0.45776244  0.07103458  0.10370142  0.5602209 ]
 [ 0.86361966  0.36086025  0.93150345  0.890938    0.53247695]
 [ 0.645624    0.42150495  0.31808867  0.59021301  0.2513742 ]
 [ 0.01196888  0.4043384   0.80385582  0.68925875  0.0472847 ]]
修改形状后：
[[ 0.19856203  0.45776244  0.07103458  0.10370142  0.5602209   0.86361966
   0.36086025  0.93150345  0.890938    0.53247695]
 [ 0.645624    0.42150495  0.31808867  0.59021301  0.2513742   0.01196888
   0.4043384   0.80385582  0.68925875  0.0472847 ]]
-------------修改形状第二种方式：使用reshape方法
[[ 0.8672595   0.04397231  0.48352773  0.3510166   0.49659962]
 [ 0.12089336  0.09130583  0.34194519  0.74917258  0.25597501]
 [ 0.66262208  0.58986883  0.83675057  0.42351253  0.35856843]
 [ 0.52635669  0.54592925  0.59734162  0.16027802  0.26060857]]
-------
[[ 0.8672595   0.04397231  0.48352773  0.3510166 ]
 [ 0.49659962  0.12089336  0.09130583  0.34194519]
 [ 0.74917258  0.25597501  0.66262208  0.58986883]
 [ 0.83675057  0.42351253  0.35856843  0.52635669]
 [ 0.54592925  0.59734162  0.16027802  0.26060857]]

4. NumPy基本操作

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

##矢量化是
import numpy as np

arr = np.array([1, 2, 3, 4, 5])
#------1、数组与标量之间的运算---
#数组和标量相加
print(arr + 2)
#数组和标量相减
print(arr - 2)
#数组和标量相乘
print(arr * 2)
#数组和标量相除
print(arr / 2)
#标量除以数组
print(1 / arr)
#数组和标量的乘方
print(arr ** 2)
#标量和数组的乘方
print(2 ** arr)
输出结果：
[3 4 5 6 7]
[-1  0  1  2  3]
[ 2  4  6  8 10]
[ 0.5  1.   1.5  2.   2.5]
[ 1.          0.5         0.33333333  0.25        0.2       ]
[ 1  4  9 16 25]
[ 2  4  8 16 32]

# ------2、数组和数组之间的运算
print("2、数组和数组之间的运算")
# 定义两个形状相同的数组
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[4.6, 3.2, 2.1], [5.2, 4.3, 3.4]])
# 数组之间的相加，就是对应的元素值相加
print(arr1 + arr2)
# 数组相减，就是对应的元素相减
print(arr1 - arr2)
# 数组相乘，就是对应的元素相乘
print(arr1 * arr2)
# 数组相除，就是对应的元素相除
print(arr1 / arr2)
# 数组乘方，就是对应的元素乘方
print(arr1 ** arr2)
输出结果：
2、数组和数组之间的运算
[[ 5.6  5.2  5.1]
 [ 9.2  9.3  9.4]]
[[-3.6 -1.2  0.9]
 [-1.2  0.7  2.6]]
[[  4.6   6.4   6.3]
 [ 20.8  21.5  20.4]]
[[ 0.2173913   0.625       1.42857143]
 [ 0.76923077  1.1627907   1.76470588]]
[[  1.00000000e+00   9.18958684e+00   1.00451086e+01]
 [  1.35117610e+03   1.01291037e+03   4.42297262e+02]]

数组相乘举例

##二维矩阵与三维矩阵如何相乘

import numpy as np

# 两个数组可以相乘的前提是：
# 要么两个对应维度上个数相等，要么其中一个个数为1
arr1 = np.ones((3, 4, 5))
arr2 = np.ones((3, 4)) * 3

print("arr1:\n", arr1)
print("arr2:\n", arr2)

print("arr2None:", arr2[:, :, None])
print("arr2None:", arr2[:, :, None].shape)

# 升维，将二维转为三维，三维上值都是None
# 这样才能与另一个三维数组相乘
arr3 = arr2[:, :, None]

# 两个三维数组相乘,相乘结果的维度是： (3, 4, 5)
dotArr = arr1 * arr3
print("dotArr:\n", dotArr)
print("dotArr.shape:\n", dotArr.shape)

4.2 数组的矩阵积

矩阵：多维数组就是矩阵
矩阵积：两个二维矩阵（行和列的矩阵），满足第一个矩阵的列数和第二个矩阵的行数相同，就可以进行矩阵乘法，即矩阵积，矩阵积不是元素级的运算。也称为点积、数量积。

矩阵乘积计算公式是：

3 × 3的矩阵 乘以 3 × 2矩阵，结果应该为3 × 2的矩阵，c_ij位置上的值为A中第i行的每一个元素和B中第j列中对应元素相乘后的累加值。
举例：


矩阵相乘代码如下：

print("=======矩阵积")
arr1 = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])
arr2 = np.array([
    [11, 12],
    [21, 22],
    [31, 32]
])
print("=======arr1.dot(arr2)")
print(arr1.dot(arr2))
print("========np.dot(arr1,arr2)")
print(np.dot(arr1, arr2))
输出：
=======矩阵积
=======arr1.dot(arr2)
[[146 152]
 [335 350]
 [524 548]]
========np.dot(arr1,arr2)
[[146 152]
 [335 350]
 [524 548]]

4.3 数组的索引与切片

对一个多维数组的索引是通过行编号和列编号来进行的，编号从0开始。

print("=======多维数组的索引==")
arr = np.array([
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 8, 7, 6]
    ],
    [
        [11, 12, 13, 14],
        [15, 16, 17, 18],
        [21, 22, 23, 24]
    ]
])
print('第一种索引,是直接用各个维度的索引取数')
print(arr[1])
print("-----------")
print(arr[1, 1])
print("-----------")
print(arr[1, 1, 2])

print('第二种索引：是根据维度一层层地深入去取数')
print(arr[1])
print("-----------")
print(arr[1][1])
print("-----------")
print(arr[1][1][2])

print("----切片----")
#要切出
#[12,13
# 16,17]
#这一块
print(arr)
print("第一种切片，是正确的，可以根据索引来切片")
print(arr[1, 0:2, 1: 3])
print("第二种切片：不能获取跨维度的切片，因为是按维度逐层去取的数据")
print(arr[1][0:2][1:3])

输出：
=======多维数组的索引==
第一种索引,是直接用各个维度的索引取数
[[11 12 13 14]
 [15 16 17 18]
 [21 22 23 24]]
-----------
[15 16 17 18]
-----------
17
第二种索引：是根据维度一层层地深入去取数
[[11 12 13 14]
 [15 16 17 18]
 [21 22 23 24]]
-----------
[15 16 17 18]
-----------
17
----切片----
[[[ 1  2  3  4]
  [ 5  6  7  8]
  [ 9  8  7  6]]

 [[11 12 13 14]
  [15 16 17 18]
  [21 22 23 24]]]
第一种切片，是正确的，可以根据索引来切片
[[12 13]
 [16 17]]
第二种切片：不能获取跨维度的切片，因为是按维度逐层去取的数据
[[15 16 17 18]]

切片是对原数组的一个视图，而不是一个副本，所有对切面的修改，也会影响到原数组，看下面这个例子：

arr = np.array([
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 8, 7, 6]
    ],
    [
        [11, 12, 13, 14],
        [15, 16, 17, 18],
        [21, 22, 23, 24]
    ]
])

ap=arr[1,0:2,1:3]
print("切片为：")
print(ap)
ap[0,0]=0
print("修改后的切片")
print(ap)
print('对切片修改后的原数组，发现原数组也变为0了，说明切片是原数组的一个视图，而不是一个副本')
print(arr)

输出为：
切片为：
[[12 13]
 [16 17]]
修改后的切片
[[ 0 13]
 [16 17]]
对切片修改后的原数组
[[[ 1  2  3  4]
  [ 5  6  7  8]
  [ 9  8  7  6]]

 [[11  0 13 14]
  [15 16 17 18]
  [21 22 23 24]]]

还有一种索引方式是布尔类型索引，要求用一个和被索引数组形状一致的数组去索引，这个数组的值都为布尔值类型，看下面这个例子：

print("布尔类型索引")
#要求用布尔值索引出小于0.5的所有值
#随机生成一个二维数组A
A = np.random.random((4, 4))
print("A的值为：")
print(A)

#根据A生成一个索引数组B
B = A < 0.5
print("B为：")
print(B)
# 以一个值为True、False的数组B去索引数组A,得到C
#C是A中符合条件的被索引出来的结果，一个一维数组
C = A[B]
print("C为：")
print(C)
布尔类型索引
A的值为：
[[ 0.12642678  0.7026479   0.05010025  0.16969393]
 [ 0.2388905   0.31833081  0.78386769  0.47662212]
 [ 0.72022402  0.50281144  0.65352421  0.69764067]
 [ 0.23633957  0.78728555  0.81619475  0.38942091]]
B为：
[[ True False  True  True]
 [ True  True False  True]
 [False False False False]
 [ True False False  True]]
C为：
[ 0.12642678  0.05010025  0.16969393  0.2388905   0.31833081  0.47662212
  0.23633957  0.38942091]

布尔类型索引的实例：

print("布尔类型索引实例")
names = np.array(["张三", '李四', '王五'])
classs = np.array(['语文', '数学', '英语', '科学'])
scores = np.array([
    [98, 97, 86, 80],
    [58, 56, 54, 51],
    [78, 85, 85, 77]
])

print("张三的所有成绩分数：")
# 张三的所有成绩
# name=="张三"是得到一个索引数组，是一行三列的[True False False]
# 通过索引数组，对scores进行索引，因为只有第一个是True，所以scores只返回第一行。
# reshape是将数组改变形状。
print(scores[names == "张三"].reshape((-1,)))

print("得到张三的数学分数")
# 在所有分数的结果基础上，在进行一次布尔类型的索引
# class=="数学"得到的[False True False False]
print(scores[names == "张三"].reshape((-1,))[classs == "数学"])

print("得到两个人的分数")
print(scores[(names == "张三") | (names == "李四")])

花式索引：

print("花式索引：")
arr = np.arange(32).reshape((8, 4))
print("源数组为：")
print(arr)

print("1、指定取第0、3、5行的数据")
print(arr[[0, 3, 5]])
print("2、从源数组中，获取第(0,0)、(3,3)、(5,2)位置的元素")
print(arr[[0, 3, 5], [0, 2, 3]])
print("3、获取第0、3、5行的第0、2、3列的数据")
# arr[[0, 3, 5]]是先取得0、3、5行
# .T是将0、3、5行组成的矩阵进行转置，转置是将行变为列，列变为行
# 转置后再取0、2、3行，其实就是取的原来的0、2、3列
# 将结果再转置回来
print(arr[[0, 3, 5]].T[[0, 2, 3]].T)
print("4、另一种获取第0、3、5行第0、2、3列的方法")
#ix_方法是指定行和列获取数据的方法，是先获取指定的行，然后在对获取的结果再取指定的列
print(arr[np.ix_([0, 3, 5], [0, 2, 3])])

举例：
交换矩阵的其中两行

import numpy as np

#######第一种方法：用中间变量置换 #########
arr = np.arange(20).reshape(4, 5)
print("1.原始为:\n", arr)

temp = arr[1].copy()
arr[1] = arr[0].copy()
arr[0] = temp
print("1.换后：\n", arr)

#######第二种方法：利用数组切片方式 #########
arr = np.arange(20).reshape(4, 5)
print(".原始为:\n", arr)

# 第一个维度上的0到1，换为第一个维度上的1到0
arr[[0, 1]] = arr[[1, 0]]
print("2.换后：\n", arr)

#######第三种方法：利用np._ix方法 #########

arr = np.arange(20).reshape(4, 5)
print("3.原始为:\n", arr)

# 第一个维度上的0到1，用np._ix获取第1到0行
arr[[0, 1]] = arr[np.ix_([1, 0])]
print("3.换后：\n", arr)

4.4 数组的转置与轴对换

数组转置是将shape进行重置操作，并将其值重置为原始shape元组的倒置，比如原来是(2,3,4)，转置后的形状就是(4,3,2)。
对于二维数组（矩阵）而言，转置就是矩阵的转置，即行变列、列变行。
transpose函数或者T属性是对数组进行转置。

#定义一个三维数组
arr = np.arange(24).reshape((2, 3, 4))
print("原始：")
print(arr)
print("原始形状为：", arr.shape)
print("transpose函数后：")
print(arr.transpose())
print("transpose函数后的形状为：", arr.transpose().shape)
print(".T后:")
print(arr.T)
print("T后的形状为：", arr.T.shape)
输出：
原始：
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
原始形状为： (2, 3, 4)
transpose函数后：
[[[ 0 12]
  [ 4 16]
  [ 8 20]]

 [[ 1 13]
  [ 5 17]
  [ 9 21]]

 [[ 2 14]
  [ 6 18]
  [10 22]]

 [[ 3 15]
  [ 7 19]
  [11 23]]]
transpose函数后的形状为： (4, 3, 2)
.T后:
[[[ 0 12]
  [ 4 16]
  [ 8 20]]

 [[ 1 13]
  [ 5 17]
  [ 9 21]]

 [[ 2 14]
  [ 6 18]
  [10 22]]

 [[ 3 15]
  [ 7 19]
  [11 23]]]
T后的形状为： (4, 3, 2)

4.5 通用函数

一元函数

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

二元函数

mod	元素级的去模	np.mod(arr1,arr2)
dot	两个数组的点积	np.dot(arr1,arr2)
greater、 greater_equal、 less、 less_equal、 equal、 not_equal	执行元素级别的比较运算，最终返回一个布尔型数组
logical_and、 logical_or、 logical_xor	执行元素级别的布尔逻辑运算，相当于&、|、\^
power	数组中每个元素进行指数值,后面这个例子是对数组中每个元素进行求3次方，类似于arr**3	np.power(arr,3)

import numpy as np

arr = np.array([1, -2, 4.5, -9.8, 6])
arr1 = np.array([1, 2, 4.5, 9.8, 6])
print(arr)
print("np.abs:", np.abs(arr))
print("np.fabs:", np.fabs(arr))
print("np.sqrt:", np.sqrt(arr1))
print("np.square:", np.square(arr))
print("np.exp:", np.exp(arr1))
print("np.log", np.log(arr1))
print("np.log10", np.log10(arr1))
print("np.log2", np.log2(arr1))
print("np.log1p", np.log1p(arr1))
print("np.sign", np.sign(arr))
print("np.ceil", np.ceil(arr))
print("np.floor", np.floor(arr))
print("np.rint", np.rint(arr))
print("np.modf", np.modf(arr))
print("np.isnan", np.isnan(arr))
print("np.isfinite", np.isfinite(arr))
print("np.isinf", np.isinf(arr))
print("np.cos", np.cos(arr))
print("np.cosh", np.cosh(arr))

print("以下为二元函数")
arr1 = np.array([1, -2, 4.5, -9.8, 6])
arr2 = np.array([10, 10, 10, 10, 10])
print("np.mod", np.mod(arr1, arr2))
print("np.dot", np.dot(arr1, arr2))
print("np.greater",np.greater(arr1,arr2))
print("np.power",np.power(arr1,3))
输出：
----arr: [ 1.  -2.   4.5 -9.8  6. ]
np.abs: [ 1.   2.   4.5  9.8  6. ]
np.fabs: [ 1.   2.   4.5  9.8  6. ]
np.sqrt: [ 1.          1.41421356  2.12132034  3.13049517  2.44948974]
np.square: [  1.     4.    20.25  96.04  36.  ]
np.exp: [  2.71828183e+00   7.38905610e+00   9.00171313e+01   1.80337449e+04
   4.03428793e+02]
np.log [ 0.          0.69314718  1.5040774   2.28238239  1.79175947]
np.log10 [ 0.          0.30103     0.65321251  0.99122608  0.77815125]
np.log2 [ 0.          1.          2.169925    3.29278175  2.5849625 ]
np.log1p [ 0.69314718  1.09861229  1.70474809  2.37954613  1.94591015]
np.sign [ 1. -1.  1. -1.  1.]
np.ceil [ 1. -2.  5. -9.  6.]
np.floor [  1.  -2.   4. -10.   6.]
np.rint [  1.  -2.   4. -10.   6.]
np.modf (array([ 0. , -0. ,  0.5, -0.8,  0. ]), array([ 1., -2.,  4., -9.,  6.]))
np.isnan [False False False False False]
np.isfinite [ True  True  True  True  True]
np.isinf [False False False False False]
np.cos [ 0.54030231 -0.41614684 -0.2107958  -0.93042627  0.96017029]
np.cosh [  1.54308063e+00   3.76219569e+00   4.50141201e+01   9.01687249e+03
   2.01715636e+02]
以下为二元函数
-----arr1: [ 1.  -2.   4.5 -9.8  6. ]
-----arr2: [10 10 10 10 10]
np.mod [ 1.   8.   4.5  0.2  6. ]
np.dot -3.0
np.greater [False False False False False]
np.power [   1.      -8.      91.125 -941.192  216.   ]

4.6 聚合函数

(1) 常用聚合函数

函数	描述	调用方式
mean	平均值
sum	计算合计值
max	计算最大值
std	计算标准差
percentile	计算百分数	numpy.percentile(a, q, axis)
median	计算中值

print("以下为聚合函数")
arr = np.array([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
])
print("arr值为：", arr)
# axis=0是在第一个维度上进行聚合，axis=1是对第二个维度上聚合
# 计算平均值
print("mean(axis=0)", arr.mean(axis=0))
print("mean(axis=1)", arr.mean(axis=1))
print("sum", arr.sum(axis=0))
# 计算标准差
print("std:", arr.std(axis=0))
输出：
以下为聚合函数
arr值为： [[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
mean(axis=0) [ 5.  6.  7.  8.]
mean(axis=1) [  2.5   6.5  10.5]
sum [15 18 21 24]
std: [ 3.26598632  3.26598632  3.26598632  3.26598632]

(2) axis参数
axis参数一般用在聚合函数中，用于指定在哪个维度上进行聚合。

import numpy as np

# 创建一个三维数组，形状为2*3*1的
arr = np.random.randint(0, 10, (2, 3, 1))
print("arr:\n", arr)

# 在第一个维度上sum
print("axis=0:\n", arr.sum(axis=0))

# 在第二个维度上sum
print("axis=1:\n", arr.sum(axis=1))

# 在第三个维度上sum
print("axis=2:\n", arr.sum(axis=2))

# 在倒数第一个维度上sum
print("axis=-1:\n", arr.sum(axis=-1))

(3) 例子
需求：一个四维的数组，以后两维度为单位，计算它们的和，比如一个1*2*3*4的数组，则以后面3*4维度为单位，输出1*2的sum

import numpy as np

#########第一种写法：先降维，再求和 ##################
# 定义一个四维数组，形状为1*2*3*4
arr4 = np.arange(24).reshape((1, 2, 3, 4))
print("arr4:\n", arr4)

# 将四维数组降为3维，形状应该为 1*2*12
arr3 = arr4.reshape((1, 2, -1))
print("arr3：\n", arr3)

# 对第三维进行求和
arr2 = np.sum(arr3, axis=2)
print("arr2：\n", arr2)

#########第二种写法：从高维到低维依次求和 ##################
# 定义一个四维数组，形状为1*2*3*4
arr4 = np.arange(24).reshape((1, 2, 3, 4))
# 在第四维上求和
arr3 = np.sum(arr4, axis=3)
# 在第三维上求和
arr2 = np.sum(arr3, axis=2)
print(arr2)

#########第三种写法：非得耍酷的方法（先降维，再求和） ##################
arr4 = np.arange(24).reshape((1, 2, 3, 4))

###（1）arr4.shape是得到arr4的维度，结果是(1,2,3,4)
### (2)arr4.shape[:-2]是得到（1,2）
### (3) arr4.shape[:-2] + (-1,) 是得到(1,2,-1),【尼玛，直接写(1,2,-1)不就行了吗】
### (4)最终是arr4.reshape((1,2,-1)) 变成三维
arr3 = arr4.reshape(arr4.shape[:-2] + (-1,))

##现在是（1，2,12）形状的三维数组了
##axis是在倒数第一个维度上进行sum，得到的是二维数组，就是最终结果
arr2 = np.sum(arr3, axis=-1)
print(arr2)

#########第四种写法：一步到位法 ##################
arr4 = np.arange(24).reshape((1, 2, 3, 4))

arr2 = arr4.reshape(2, 12, -1).sum(axis=1).reshape((1, 2))
print(arr2)

# 因为第一个维度上个数为1，所以形状可以直接变成两维的
# 然后再在二维上求和
# 最后将形状改为要求的1*2的
arr2 = arr4.reshape(2, -1).sum(axis=1).reshape((1, 2))
print(arr2)

4.7 np.where函数

where函数有三个参数：第一个是判断条件，第二个是如果条件为true时返回的值，第三个是当条件为false时返回的值。
举例

import numpy as np

# 定义两个矩阵
arr1 = np.random.randint(1, 20, (4, 5))
arr2 = np.random.randint(1, 20, (4, 5))
# 设置判断条件
c = arr1 < arr2
print("arr1\n", arr1)
print("arr2\n", arr2)

# 进行比较，如果符合条件，就保留arr1的数据，否则就保留arr2的数据
arr3 = np.where(c, arr1, arr2)
print("arr3\n", arr3)

4.8 np.unique函数

unique函数的作用是对数据去重。
举例：

import numpy as np

arr1 = np.random.randint(1, 20, (4, 5))

print("arr1\n", arr1)
print("unique函数后：")
print(np.unique(arr1))

4.9 其他函数

header 函数名	描述
np.insert (array,index,val )	在指定的索引位置插入指定的值
np.c_	插入一列
np.r_	插入一行

举例：

## 在数组[1, 2, 3, 4, 5]中相邻两个数字中间插入两个0

#########第三种方法：使用numpy的insert方法 ##########
arr = np.array([1, 2, 3, 4, 5])
n = 2  # 指定每隔多少个插入一个0

# 循环每一个插入0的空隙
# 最终是得到一个插入点的索引tup
tup = ()
for i in range(1,len(arr)):
    # 两个元组的+操作是连接
    # 元组*n 是复制n个元素
    tup = tup + ((i,) * n)

#在tup中指定的索引位置插入0
arr = np.insert(arr, tup, 0)
print("第三种方法：\n", arr)

#########第二种方法：np._c增加列，然后再改变形状 ##########
#在数组[1, 2, 3, 4, 5]中相邻两个数字中间插入两个0

arr = np.array([1, 2, 3, 4, 5])
n = 2

# 定义一个5*1的二维数组，元素全是0
arr0 = np.zeros(len(arr)).reshape(-1, 1)

# 使用numpy的增加列的方式增加两列0
# 要把原来是的形状改为5*1的
# np.c_是增加列，一共增加n列
t = np.c_[arr.T, arr0]
for i in range(n - 1):
    t = np.c_[t, arr0]
print("第二种方法中间结果:\n", t)

# 将结果转成一维的再将多余的0去掉
t = t.reshape(-1)[:-n]

print("第二种方法最终结果:\n", t)