python学习笔记之numpy

python学习—numpy

1. 前言与简介

NumPy(Numerical Python)是python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外提供大量的数学函数库用于数组运算。numpy在进行数组运算时，运行速度非常快。
NumPy通常与SciPy(Scientific Python)和Matplotlib(绘图库)一起使用，这一组合是一个强大的科学计算环境，能很好替代matlab，有助于帮助我们通过python学习数据科学或者机器学习。
上文说的scipy与numpy是有区别的：

1. scipy 函数库在numpy库的基础上增加了众多的数学、科学以及工程计算中常用的库函数。例如，线性代数、最优化、积分、常微分方程数值求解、快速傅里叶变换、信号处理、图像处理、稀疏矩阵等
2. scipy一般都是操控numpy数组来进行科学计算、统计分析。
3. scipy需要依赖numpy的支持进行安装和运行。scipy是在numpy的基础上构建的更强大、应用领域更广的科学计算包。

matplotlib是python和numpy的可视化操作界面。

2. numpy的数据类型与基本操作

2.1 ndarray 数据类型

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

名称	说明
bool_	布尔类型（true or False）
int_	默认的整型
int8 、int16、 int32、 int64	字节（-128 to 127）、整数、整数 、整数
uint8、uint16、 uint32 、 uint64	无符号整数（0 to 255）、无符号整数 、无符号整数 、无符号整数
float_	float类型的简写
float16、float32、float64	半、单、双精度浮点数
complex_	complex128类型的简写，128位复数
complex64、complex128	双32位、双64位浮点数

numpy 的数据类型实际上是dtpye对象的实例，并对应唯一的字符，包括np.bool_，np.int32，np.float32，等。

2.2 ndarray 对象

1. numpy最重要的一个特点是其N维数组对象ndarray，它是一系列同类型数据的集合，以0下标为开始进行集合中元素的索引。
2. ndarray 对象是用与存放同类型元素的多维数组。
3. ndarray 中的每个元素在内存中都有相同存储大小的区域。

创建一个ndarray 只需要调用 numpy 的array函数即可，使用格式如下：

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

参数描述：

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

例子：

import numpy as np
a = np.array([1,2,3])  #创建一个ndarray类型的数组
print(a)
b = np.array([1,2,3,4,5], ndmin =2)  #创建一个ndarray类型的数组，并且最小维度为2
print( b)

2.3 numpy 创建数组

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

1. numpy.empty ---- 未初始化，元素随机
2. numpy.zeros ----全为0
3. numpy.ones ----全为1
4. numpy.asarray ---- 与 numpy.array 类似
5. numpy.arange ----元素是一定范围的数
6. numpy.linspace ----一维数组，等差数列创建
7. numpy.logspace ---- 等比数列创建

演示代码：

## numpy.empty 方法创建一个指定形状、数据类型且未初始化的数组：
# 使用格式
numpy.empty(shape, dtype, order)
# shape 创建数组的形状
x = np.empty([6,2],dtype = int) #创建一个6行2列、元素类型为整数型且未初始化
————————————————————————————————
## numpy.zeros 创建指定大小的数组，数组元素以0来填充
#使用格式
numpy.zeros(shape, dtype = float, order = 'C')  #参数描述如上文
y = np.zeros((5,2), dtype = int) #创建一个5行2列、元素类型为整型且元素全为0的数组
————————————————————————————————
## numpy.ones 创建指定大小的数组，数组元素以1来填充
#使用格式
numpy.ones(shape, dtype = None, order = 'C')  #参数描述如上文
y = np.ones((5,2), dtype = int) #创建一个5行2列、元素类型为整型且元素全为1的数组
————————————————————————————————
## numpy.asarray 与 numpy.array 类似, 但numpy.asarray参数只有三个，比numpy.array少2个
# 使用格式
numpy.asarray(a , dtype = None, order = None) 
# 参数a 可以是任意形式的输入参数，可以是，列表、元组、列表的元组、元组的列表、元组的元组、多维数组
q = (1,2,3)
p = np.asarray(q) #将元组变成ndarray对象的数组
print(p)
# 输出 ：[1 2 3] <class 'numpy.ndarray'>
————————————————————————————————
## numpy.arange 使用arange函数创建数值范围并返回ndarray对象
# 使用格式
numpy.arange(start, stop, step, dtype)
# dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
x = np.arange(5)  #生成0到4，步长为1的数组
x = np.arange(5,8,2)  #生成5到7，步长为2的数组
————————————————————————————————
## numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列
# 使用格式
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# start 起始值
# stop 终止值，如果endpoint为true,该值包含于数列中。为了保持前闭后开原则，最好选False
# num 要生成等步长元素的个数
# endpoint 默认是true
# retstep如果为true时，生成的数组中会显示间距，反之不显示。默认不显示
# dtype 数据类型
y = np.linspace(11,20,10, retstep = True) #生成11到20 ，元素数量为10，显示两元素间距
y = np.linspace(11,20,10,endpoint =False) 
#生成11到19 ，元素数量为10，不显示两元素间距
————————————————————————————————
## numpy.logspace 函数用于创建一个等比数列。
#使用格式
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
#base 是对数log的底数
zg = np.logspace(2,4,num = 11)  #10的2次到10的4次生成等比数列，个数11个

2.4 numpy 数据属性

numpy 数组的维数成为秩（rank），秩=轴（axis）的数量=数组的维度的数量，一维数组的秩为1，二维数组的秩为2
numpy 的数组中比较重要的 ndarray 对象属性有：

属性	说明
ndarray.ndim	秩
ndarray.shape	数值的维度，对于二维矩阵维度是n行m列
ndarray.size	数组元素的总个数，相当于.shape中n*m的值
ndarray.dtype	元素的类型
ndarray.itemsize	元素的大小，以字节为单位
ndarray.flags	存储信息
ndarray.real	元素的实部
ndarray.imag	元素的虚部

a = np.arange(24)
print(a,a.ndim)  #一维
b = a.reshape(3,4,2) #3*4*2=24 ,现在是三维
print(b,b.ndim) 

2.5 numpy 索引与切片

ndarray 对象的内容可以通过索引或切片来访问和修改，与python中list的切片操作类似。
ndarray 数组可以基于小表进行索引，切片对象可以通过内置的slice函数，并设置start,stop和step参数进行，从原数组中切割出一个新数组。

#一维数组索引切片
a = np.arange(10)
s = slice(2,7,2) # 2 到6 ，步长为2，进行切片
print(a[s])  # 依照s的切片方式切a
# 用冒号分隔切片参数
print(a[2:7:1]) ## 2 到6 ，步长为1，对a进行切片
# 冒号的解释：
#a[2]  返回与该索引对应的元素
#[2:]  提取从该索引开始到最后的元素
#[2:7]  提取2到6索引的元素
——————————————————————
#多维数组索引切片 a[起始索引，结束索引] 索引指的是最外层索引，提取第二层元素，第二层可能是1维或多维，提取的新数组也是原数组维数
a = np.array([[1,2,3],[3,4,5],[4,5,6]]) #3行3列的二维数组
print(a)
print(a[1:2]) #提取第一个位置的项
# 输出：[[3 4 5]]

numpy 比一般的python序列提供更多的索引方式。除了用整数和切片的索引外，数组可以由一下索引：

1. 整数数组索引
2. 布尔索引
3. 花式索引

整数数组索引
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
b = a[[0,1,2],[0,1,0]] # 取出a中(0,0),(1,1),(2,0)上的数字
print(b)
# 输出：[1 4 4]
布尔索引
布尔索引是通过布尔运算（如，比较运算符）来获取符合指定条件的元素的数组。
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  # 创建一个4行3列的数组
print (x[x >  5])  #  输出x中大于5的元素
# 输出： [ 6  7  8  9 10 11]

花式索引
1.花式索引是利用整数数组进行索引
2.花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。
3.对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素，如果目标是二维数组，那么就是对应下标的行。
#一维数组
x = np.array([2,1,3,4,12,5,6,7])
x2 = x[[0, 6]] #取出第0个位置，第6个位置的元素
print(x2)
#二维数组
x=np.arange(32).reshape((8,4)) #创建一个8行4列的数组
print (x[[4,2,1,7]]) #取出第4，2，1，7行
#输出：
[[16 17 18 19]
 [ 8  9 10 11]
 [ 4  5  6  7]
 [28 29 30 31]]

2.6 numpy 数组操作

本节主要介绍一下内容：

1. 迭代数组
2. numpy 的广播机制
3. numpy数组操作

2.6.1 迭代数组

NumPy迭代器对象numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
迭代器最基本的任务是可以完成对数组元素的访问。
对数组使用nditer进行迭代。

a = np.arange(6).reshape(2,3) #创建2行3列数组
for x in np.nditer(a): 
    print(x,end = ",")

在遍历时，我们可以控制遍历顺序
#for x in np.nditer(a,order = "F"): Fortran order,列序优先；
#for x in np.nditer(a,order = "C"): C order,行序优先，默认；
for x in np.nditer(a,order = "F"):  #列序优先
    print(x,end = ",")
# 输出：0,3,1,4,2,5,
for x in np.nditer(a,order = "C"):  # 行序优先
    print(x,end = ",")
# 输出：0,1,2,3,4,5,

2.6.2 numpy 的广播机制

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

1. 数组形状相同的计算：（a.shape == b.shape）
   形状相同是指维数相同，各维度长度相同。
   a*b的结果是a,b数组对应元素相乘。
2. 数组形状不同的计算：numpy将自动触发广播机制。
   广播规则的简单理解：对两个数组，形状不相同，如果一个数组能内部操作变成和另外一个数组形状相同，就满足广播规则。不满足广播机制原则对两个数组操作就会报错。
   

a = np.array([[ 0, 0, 0],   
           [10,10,10],
           [20,20,20],
           [30,30,30]])  #创建一个4行3列的数组
b = np.array([0,1,2])  #创建一个一行3列的数组
print(a + b) 
# 触发广播机制，先将b变成和a一样的形状，如何变？
#将b的第一行复制填充到剩下行，使得和a的形状一样。

2.6.3 numpy数组操作

numpy中包含了一些函数用于处理数组，可以分为一下类型：

1. 修改数组形状
2. 反转数组
3. 修改数组维度
4. 连接数组
5. 分割数组
6. 数组元素的添加与删除

2.6.3.1 修改数组形状

①numpy.reshape
numpy.reshape 函数可以在不改变数据的条件下修改形状，使用格式如下：
numpy.reshape(arr, newshape, order=“C”)
arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状（能兼容：里面元素个数要一样，（23）=（16）=（3*2））
order：‘C’–按行，‘F’–按列，‘A’–原顺序，‘K’–元素在内存中出现的顺序
演示如下：

b=np.arange(8)
a=b.reshape(2,4) #将一行8列的b，修改成2行4列的a，不难发现他们的元素个数未发生改变，只是形状不同
print(a)
# 输出：[[0 1 2 3]
#        [4 5 6 7]]

②numpy.ndarray.flatten
numpy.ndarray.flatten返回一份展平的数组拷贝，对拷贝所做的修改不会影响原始数据，使用格式如下：
ndarray.flatten(order=‘C’)
演示如下：

a=np.arange(8).reshape(2,4) #创建一个2行4列的数组
print(a)
print(a.flatten()) #将a展平，默认按行
# 输出：[0 1 2 3 4 5 6 7]
print(a.flatten(order='F')) #将a按列展平
# 输出：[0 4 1 5 2 6 3 7]

2.6.3.2 翻转数组

① numpy.transpose【二维中称为转置】
该函数用于对换数组的维度，numpy.ndarray.T类似numpy.transpose.使用格式：
numpy.transpose(arr,axes)
axes：整数列表，通常所有维度都会对换
演示如下：

a = np.arange(12).reshape(3,4)
print(a)
#输出：[[ 0  1  2  3]
#       [ 4  5  6  7]
#       [ 8  9 10 11]]
b = np.transpose(a) #将a转置
print(b)
#输出：[[ 0  4  8]
#       [ 1  5  9]
#       [ 2  6 10]
#       [ 3  7 11]]

② numpy.swapaxes 【与python中的transpose\permute一样】
该函数用于交换数组的两个轴，格式如下：
numpy.swapaxes(arr,axis1,axis2)
arr：输入的数组
axis1：对应第一个轴的整数
axis2：对应第二个轴的整数
演示如下：

arr=np.arange(16).reshape((2,2,4))
print(arr)
print("1,2交换\n",arr.swapaxes(1,2))  #行列调换
print("0,1交换\n",arr.swapaxes(0,1)
"""
输出：
[[[ 0  1  2  3]
  [ 4  5  6  7]]
 [[ 8  9 10 11]
  [12 13 14 15]]]
1,2交换
 [[[ 0  4]
  [ 1  5]
  [ 2  6]
  [ 3  7]]
 [[ 8 12]
  [ 9 13]
  [10 14]
  [11 15]]]
0,1交换
 [[[ 0  1  2  3]
  [ 8  9 10 11]]
 [[ 4  5  6  7]
  [12 13 14 15]]]
  """

2.6.3.3 修改数组维度

① numpy.expand_dims
该函数通过在指定位置插入新的轴来扩展数组形状，使用如下：
numpy.expand_dims(arr, axis)
axis：新轴插入的位置

x = np.array(([1,2],[3,4]))
print(x)
y = np.expand_dims(x,axis=0)  #在0轴加入新轴，即在最外层加一个方括号
print(y)
print(x.shape,y.shape)
"""
输出：
[[1 2]
 [3 4]]
[[[1 2]
  [3 4]]]
x,y的形状 (2, 2) (1, 2, 2)
"""

② numpy.squeeze
该函数从给定数组的形状中删除一维的条目，使用格式如下：
numpy.squeeze(arr, axis)

x = np.arange(9).reshape(1,3,3)  #最外层必须式1，不然报错
y = np.squeeze(x)
print(x,"\n",y)
print("x,y的形状",x.shape,y.shape)
"""
输出：
[[[0 1 2]
  [3 4 5]
  [6 7 8]]]  
  
 [[0 1 2]
 [3 4 5]
 [6 7 8]]
x,y的形状 (1, 3, 3) (3, 3)
"""

2.6.3.4 链接数组

① numpy.concatenate
该函数用于沿指定轴连接相同形状的两个或多个数组，使用格式如下：
numpy.concatenate((a1, a2, …), axis)
a1, a2, …：相同类型的数组
axis：沿着它连接数组的轴，默认为 0

a = np.array(([1,2],[3,4]))  #np.array([[1,2],[3,4]])是一样的效果
b = np.array([[5,6],[7,8]])
print(a.shape,b.shape)
print(np.concatenate((a,b)))
print(np.concatenate((a,b),axis=1))
"""
输出：
(2, 2) (2, 2)

[[1 2]
 [3 4]
 [5 6]
 [7 8]]
 
[[1 2 5 6]
 [3 4 7 8]]
"""

②numpy.stack
该函数用于沿新轴连接数组序列，使用格式如下：
numpy.stack(arrays, axis)
arrays相同形状的数组序列
axis：返回数组中的轴，输入数组沿着它来堆叠

a = np.array(([1,2],[3,4]))  #np.array([[1,2],[3,4]])是一样的效果
b = np.array([[5,6],[7,8]])
print(a.shape,b.shape)
print(np.stack((a,b)))  #沿0轴堆叠
print(np.stack((a,b),axis=1)) #沿1轴堆叠
"""
输出：
(2, 2) (2, 2)
[[[1 2]
  [3 4]]
 [[5 6]
  [7 8]]]
  
[[[1 2]
  [5 6]]
 [[3 4]
  [7 8]]]
"""

③ numpy.hstack和 numpy.vstack
这两个函数时numpy.stack函数的变体，第一个是通过水平堆叠来生成数组，第二个是通过垂直堆叠来生成数组。

a = np.array(([1,2],[3,4]))  #np.array([[1,2],[3,4]])是一样的效果
b = np.array([[5,6],[7,8]])
print(a.shape,b.shape)
print(np.hstack((a,b)))  #水平堆叠
print(np.vstack((a,b)))   #垂直堆叠
"""
输出：
(2, 2) (2, 2)

[[1 2 5 6]
 [3 4 7 8]]
 
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
"""

2.6.3.5 分割数组

①numpy.split
该函数沿特定的轴将数组分割为子数组，使用如下：
numpy.split(ary, indices_or_sections, axis)
ary：被分割的数组
indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。

a = np.arange(9)
b = np.split(a,3)  #将原数组分为3个大小相等的子数组
c = np.split(a,[4,7]) #将原数组在第四个位置、第7个位置分割
print(a,'\n',b,'\n',c)
"""
输出：
[0 1 2 3 4 5 6 7 8] 
 [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])] 

 [array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
"""

2.6.3.6 数组元素的添加与删除

①numpy.append
该函数在数组的末尾添加值，追加操作会分配整个数组，并把原来的数组复制到新数组中。此外，输入数组的维度必须匹配，不然会报错。
append函数返回的始终是一个一维数组。
numpy.append(arr, values, axis=None)
arr：输入数组
values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
axis：默认为 None。
当axis无定义时，是横向加成，返回总是为一维数组！
当axis有定义的时候，分别为0和1的时候。
当axis为0时，数组是加在下边（列数要相同）。
当axis为1时，数组是加在右边（行数要相同）。

a = np.array([[1,2,3],[4,5,6]]) # 这是一个二维数组，axis=0是指行，axis=1是指列
print(a.shape)
print(np.append(a,[7,8,9]))  #先把a展平，在后面加[7,8,9]，输出为一维
print(np.append(a,[[7,8,9]],axis=0)) #加行，要求列要相同
print(np.append(a,[[5,5,5],[7,8,9]],axis = 1)) #加列，要求行要相同
"""
输出：
(2, 3)
[1 2 3 4 5 6 7 8 9]

[[1 2 3]
 [4 5 6]
 [7 8 9]]
 
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]
"""

② numpy.insert
该函数在给定索引之前，沿给定轴在输入数组中插入值。
numpy.insert(arr, obj, values, axis)
arr：输入数组
obj：在其之前插入值的索引
values：要插入的值
axis：沿着它插入的轴，如果未提供，则输入数组会被展开

a = np.array([[1,2],[3,4],[5,6]])
print ('第一个数组：')
print (a)
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.insert(a,3,[11,12]))  #3是展开后的第3个位置
print ('传递了 Axis 参数。 会广播值数组来配输入数组。')
print ('沿轴 0 广播：')
print (np.insert(a,1,[11],axis = 0))  #1是第1行位置，其实是第二行了，因为我们是从第0行开始所以是第一行

print ('沿轴 1 广播：') # 1是第1列位置，其实是第二列了，因为我们是从第0列开始所以是第一列
print (np.insert(a,1,11,axis = 1))
"""
第一个数组：
[[1 2]
 [3 4]
 [5 6]]
 
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]

传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]
 
沿轴 1 广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]
"""

③ numpy.delete
该函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开，使用格式如下：
numpy.delete(arr, obj, axis)
arr：输入数组
obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.delete(a,5))
print ('\n')

print ('删除第二行：')
print (np.delete(a,1,axis = 0))
print ('\n')
 
print ('删除第二列：')
print (np.delete(a,1,axis = 1))
print ('\n')
 
print ('包含从数组中删除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))  # 删掉偶数位置的值
"""
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]
删除第二行：
[[ 0  1  2  3]
 [ 8  9 10 11]]

删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]
包含从数组中删除的替代值的切片：
[ 2  4  6  8 10]
"""

3. numpy的函数与常用功能

3.1 NumPy 字符串函数

函数	说明
add()	随两个数组逐个字符串元素进行链接
multiply()	返回按元素多重连接后的字符串
center()	居中字符串
title()	将字符串中的每个单词的第一个字母转换为大写
capitalize()	将字符串的第一个字母转为大写
lower()	数组元素转换为小写
upper()	数组元素转化为大写
split()	指定分隔符对字符串进行分割，返回数组列表
splitlines()	返回元素中的行列表，以换行符分割
strip()	移除元素开头或者结尾处的特定字符
join()	通过指定分隔符来链接数组中的元素
replace()	使用新字符串替换字符串中所有子字符串
decode()	解码
encode()	编码

3.2 NumPy 数学函数

numpy中包含大量的各种数学运算的函数，包括撒娇函数，算术运算的函数，复数处理函数等。numpy提供了标准的三角函数。

3.2.1 三角函数

import numpy as np
a = np.array([0,30,45,60,90])
print(np.sin(a*np.pi/180))  #计算a中度数的sin值
print(np.cos(a*np.pi/180))
print(np.tan(a*np.pi/180))

3.2.2 舍入函数

主要的舍入函数有：

1. numpy.around() 函数返回指定数字的四舍五入值，可以指定保留几位小数的四舍五入
2. numpy.floor() 向下取整。
3. numpy.ceil() 向上取整。

a = np.array([1.545,23.4563])
print(np.around(a)) #四舍五入到整数部分，无小数
print(np.around(a,decimals=2))  #保留2位小数的四舍五入
print(np.floor(a))  #向下取整
print(np.ceil(a))  #向上取整

"""
输出：
[ 2. 23.]
[ 1.54 23.46]
[ 1. 23.]
[ 2. 24.]
"""

3.3 NumPy 统计函数

主要的统计函数有：

3.3.1 numpy.amin() 和 numpy.amax()

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print(a)
print(np.amin(a)) #计算所有元素的min
 # a是二维数组，只有行和列0代表行，1代表列 
print(np.amin(a,axis = 0)) #计算每一行min
print(np.amin(a,1))  #计算每一列min
"""
输出：
[[3 7 5]
 [8 4 3]
 [2 4 9]]
 
2

[2 4 3]

[3 3 2]
"""

3.3.2 numpy.percentile() 百分数

numpy.percentile(a, q, axis)
说明：
a: 输入数组
q: 要计算的百分位数，在 0 ~ 100 之间
axis: 沿着它计算百分位数的轴

a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print(np.percentile(a,50))  #计算50%分位数，a排序后的中位数
 # a是二维数组，只有行和列0代表行，1代表列 
print (np.percentile(a, 50, axis=0)) #计算每一行50% 分位数
print (np.percentile(a, 50, axis=1)) #计算每一列50% 分位数
print (np.percentile(a, 50, axis=1, keepdims=True)) #计算每一列50% 分位数 维数不变
"""
输出：
4.0

[3. 4. 5.]

[5. 4. 4.]

[[5.]
 [4.]
 [4.]]
"""

3.3.3 中位数、均值、加权平均、方差、标准差

①numpy.median()
numpy.median(a, axis) 函数用于计算数组 a 中元素的中位数（中值）

②numpy.mean()
numpy.mean(a, axis) 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。算术平均值是沿轴的元素的总和除以元素的数量。

③numpy.average()【没有权重的时候=mean】
numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。
加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

a = np.array([1,2,3,4])  
w = np.array([1,3,2,1])
print(np.average(a))
print(np.average(a,weights=w))
'''
输出：
2.5
2.4285714285714284
'''

 方差、标准差
 import numpy as np 
print (np.std([1,2,3,4]))  #计算标准差
print (np.var([1,2,3,4]))  #计算方差

3.3.4 排序

①numpy.sort()
numpy.sort() 函数返回输入数组的排序副本。函数格式如下：
numpy.sort(a, axis, kind, order)
说明：
a: 要排序的数组
axis: 沿着它排序数组的轴， axis=0 按列排序，axis=1 按行排序
kind: 默认为’quicksort’（快速排序）
order: 如果数组包含字段，则是要排序的字段

② numpy.argsort()
numpy.argsort() 函数返回的是数组值从小到大的索引值。

③ numpy.argmax() 和 numpy.argmin()
numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

④ numpy.where()
numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
⑤ numpy.extract()
numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。

a = np.array([[3,7],[9,1]])  
print (np.sort(a, axis =  0)) #按列排序从小到大
print (np.sort(a, axis =  1)) #按行排序从小到大
y = np.where(a >  3)  
print(y)
print(a[y])
"""
输出：
[[3 1]
 [9 7]]
 
[[3 7]
 [1 9]]
 
(array([0, 1], dtype=int64), array([1, 0], dtype=int64))

[7 9]
"""
a = np.array([[3,7],[9,1]])  
y = np.where(a >  3)  
print (np.extract(y, a))
"""
输出：[7 9]
"""

3.4 NumPy 副本与视图

副本是一个数据完整的拷贝，如果我们对副本进行修改，他不会影响原始数据，物理内存不在同一位置。
视图是数据的别称或引用，通过该别称或引用便于访问、操作原有数据，但原有数据不会产生拷贝。如果我们对视图进行修改时会影响到原始数据，物理内存在在同一位置。
副本一般发生在：

1. python 序列的切片操作，调用deepCOPY()函数。
2. 调用ndarray的copy()函数产生一个副本。

视图一般发生在：

1. numpy 的切片操作返回原数据的视图。
2. 调用ndarray 的view() 函数产生一个视图。

赋值：
简单的赋值不会创建数组对象的副本。相反，它使用原始数组的相同id()来访问它。id()返回python对象的通用标识符，类似于C中的指针。对赋值后的数组进行修改时，原数组也会修改。【任何变化都会改变】

import numpy as np
a = np.arange(6)
b = a  #将a赋值给b
print(id(a),id(b))  #打印a,b的id---相同
b.shape=(3,2)  #修改b的形状
print(b) 
print(a) #a的形状也改了
"""
2065586899440 2065586899440
[[0 1]
 [2 3]
 [4 5]]
[[0 1]
 [2 3]
 [4 5]]
"""

3.4.1 视图或浅拷贝

ndarray.view()方法创建一个新的数组对象，该方法创建的新数组的维数变化不会改变原始数组的维数。
但使用切片创建视图修改数据会影响到原始数组。
演示如下：

a = np.arange(6).reshape(3,2)
print(a)
b = a.view()  #创建新的数组对象给b
print(id(a),id(b))   #打印id，两者不同
b.shape=(2,3)
print(b)  #b的形状改变
print(a)   #a的形状没有改变
"""
输出：
2065586899440 2065586899440
[[0 1]
 [2 3]
 [4 5]]
[[0 1]
 [2 3]
 [4 5]]
 """
a = np.arange(12)
b = a[3:]
c = a[3:]
b[1] = 123
c[2] = 234
print(a[3:],"\n",b,'\n',c)
print(id(a),id(b),id(c))
"""
[  3 123 234   6   7   8   9  10  11] 
 [  3 123 234   6   7   8   9  10  11] 
 [  3 123 234   6   7   8   9  10  11]
2065576311376 2065576310608 2065576115632
"""

总结：

1. 赋值一定会变，id相同
2. b = ndarray.view() 维数不变，id不同
3. 切片创建视图会变，id不同

3.4.2 副本或深拷贝

ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。

a = np.array([[10,10],[2,3],[4,1]])
b = a.copy()  #a深拷贝到b
print(id(b),id(a))  #id不同
print(b is a)  #能不能改变b来改变a 
b[0][0]=100  #改变b的[0,0]

print(b,"\n",a)  #b改变，a没变
'''
2065576310512 2065576311664
False
[[100  10]
 [  2   3]
 [  4   1]] 
 [[10 10]
 [ 2  3]
 [ 4  1]]
'''

4. numpy Matplotlib

Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。
Matplotlib 库需要先改装：pip install matplotlib
画cosx的图像

import numpy as np
import math
from matplotlib import pyplot as plt

x = np.arange(-10,10,0.001)
y = np.cos(x)
plt.rcParams['font.sans-serif']=['SimHei']  #两行代码为了让图表题不乱码
plt.rcParams['axes.unicode_minus'] = False   #两行代码为了让图表题不乱码
plt.title("cosx的图像")
plt.xlabel("x")
plt.ylabel("y")
plt.plot(x,y)
plt.show()

以上实例中，np.arange() 函数创建 x 轴上的值。y 轴上的对应值存储在另一个数组对象 y 中。 这些值使用 matplotlib 软件包的 pyplot 子模块的 plot() 函数绘制。
作为线性图的替代，可以通过向 plot() 函数添加格式字符串来显示离散值。 可以使用以下格式化字符。

若将上面的线用圆点代替，只需plt.plot(x,y, “o”)

bar()

pyplot 子模块提供 bar() 函数来生成条形图。 以下实例生成两组 x 和 y 数组的条形图。

from matplotlib import pyplot as plt
x =  [5,8,10] 
y =  [12,16,6] 
x2 =  [6,9,11] 
y2 =  [6,15,7] 
plt.bar(x,y,align = 'center')
plt.bar(x2,y2,color = 'g',align = 'center')
plt.title("这是柱状图")
plt.ylabel('Y')
plt.xlabel('x')
plt.show()

numpy.histogram()

numpy.histogram()函数是数据的频率分布的图形表示。水平尺寸相等的矩形对应于类间隔，称为 bin，变量 height 对应于频率。

from matplotlib import pyplot as plt 
import numpy as np
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])  #原始数据
plt.hist(a,bins = [1,10,20,30,40,50,60,70,80])  #虽然是histogrem,用的时候只需要hist
plt.title("数据的频率分布")

Matplotlib 绘制多图

我们可以使用pyplot中的subplot()和subplots()方法来绘制多个子图。
subplot() 方法在绘图时需要指定位置，subplots() 方法可以一次生成多个，在调用时只需要调用生成对象的 ax 即可。
subplot(nrows, ncols, index, **kwargs)
以上函数将整个绘图区域分成 nrows 行和 ncols 列，然后从左到右，从上到下的顺序对每个子区域进行编号 1…N ，左上的子区域的编号为 1、右下的区域编号为 N，编号可以通过参数 index 来设置。

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 400)  #产生0-2pi之间400个点
y = np.sin(x**2)  #计算sin(x的平方)
# 只画一个图
fig,ax = plt.subplots()
ax.plot(x,y)
ax.set_title('Simple plot')
#画两个图
fig,(ax1,ax2) = plt.subplots(1,2)
ax1.plot(x, y)
ax1.set_title('连续的图')
ax2.scatter(x, y)
ax2.set_title('离散的图')
#画4个图
fig,axs = plt.subplots(2,2) #像是创建2*2的表格
axs[0,0].plot(x,y)  #在0行0列画一个
axs[1,1].scatter(x,y)  #在1行1列画一个
plt.show()

文章暂时结束，下篇pandas学习笔记