[Python知识库]python必学库之NumPy库

NumPy

NumPy简介：

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

NumPy的应用

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。

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

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

官网地址

• NumPy 官网 http://www.numpy.org/
• NumPy 源代码：https://github.com/numpy/numpy
• SciPy 官网：https://www.scipy.org/
• SciPy 源代码：https://github.com/scipy/scipy

NumPy的安装

windows下安装

pip3 install --user numpy scipy matplotlib

–user：指定在哪个用户下安装

默认下numpy的安装使用的是国外的服务器，速度会慢，推荐使用国内的镜像进行下载，比如阿里云，清华等

pip3 install numpy scipy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

ubuntu下安装

sudo apt-get install python-numpy

如果ubuntu下有多个python版本，还可以通过指定python的版本来指定安装给哪个版本的python，比如安装在朴有天hon下

sudo apt-get install python3-numpy

CentOS下安装

sudo dnf install numpy

Mac下安装

pip3 install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

NumPy Ndarray 对象

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

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

实例化一个NumPy Ndarray对象

只需调用 NumPy 的 array 函数

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

参数说明：

NumPy 数组属性

ndarray.ndim：用于返回数组的维数，等于秩

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

1
3

ndarray.shape： 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数

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

(2, 3)

调整数组大小

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

[[1 2]
 [3 4]
 [5 6]]

除此之外，NumPy还提供了reshape方法可以调整数组的大小

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

[[1, 2] 
 [3, 4] 
 [5, 6]]

NumPy 创建数组

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

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

   numpy.empty(shape, dtype = float, order = 'C')
   

   参数说明:

   参数	描述
   shape	数组形状
   dtype	数据类型，可选
   order	有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

   举例：创建一个空数组

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

   注意 ? 数组元素为随机值，因为它们未初始化。

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

   numpy.zeros(shape, dtype = float, order = 'C')
   

   参数说明：

   参数	描述
   shape	数组形状
   dtype	数据类型，可选
   order	‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组

   举例:

   import numpy as np
    
   # 默认为浮点数
   x = np.zeros(5) 
   print(x)
    
   # 设置类型为整数
   y = np.zeros((5,), dtype = np.int) 
   print(y)
    
   # 自定义类型
   z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
   print(z)
   

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

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

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

   参数说明：

   参数	描述
   shape	数组形状
   dtype	数据类型，可选
   order	‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组

   举例：

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

   [1. 1. 1. 1. 1.]
   [[1 1]
    [1 1]]
   

4. 从已有的数组中创建数组

   numpy.asarray：umpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个

   numpy.asarray(a, dtype = None, order = None)
   

   参数说明：

   参数	描述
   a	任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
   dtype	数据类型，可选
   order	可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

   举例：

   将列表转换为列表

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

   [1  2  3]
   

   将元组转换为列表

   import numpy as np 
    
   x =  (1,2,3) 
   a = np.asarray(x)  
   print (a)
   

   [1  2  3]
   

   将元组列表转换为列表

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

   [(1, 2, 3) (4, 5)]
   

   numpy.fromiter ：方法从可迭代对象中建立 ndarray 对象，返回一维数组

   numpy.fromiter(iterable, dtype, count=-1)
   

   参数：

   参数	描述
   iterable	可迭代对象
   dtype	返回数组的数据类型
   count	读取的数据数量，默认为-1，读取所有数据

   举例：

   import numpy as np 
    
   # 使用 range 函数创建列表对象  
   list=range(5)
   it=iter(list)
    
   # 使用迭代器创建 ndarray 
   x=np.fromiter(it, dtype=float)
   print(x)
   

   [0. 1. 2. 3. 4.]
   

5. 从已有的数组范围创建

   numpy.arange

   numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象

   numpy.arange(start, stop, step, dtype)
   

   参数：

   参数	描述
   start	起始值，默认为0
   stop	终止值（不包含）
   step	步长，默认为1
   dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

   举例：

   生成0-5的数组

   import numpy as np
    
   x = np.arange(5)  
   print (x)
   

   [0  1  2  3  4]
   

   设置返回类型为float

   import numpy as np
    
   # 设置了 dtype
   x = np.arange(5, dtype =  float)  
   print (x)
   

   [0.  1.  2.  3.  4.]
   

   设置了起始值、终止值及步长

   import numpy as np
   x = np.arange(10,20,2)  
   print (x)
   

   [10  12  14  16  18]
   

   numpy.linspace ：函数用于创建一个一维数组，数组是一个等差数列构成的

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

   参数：

   参数	描述
   start	序列的起始值
   stop	序列的终止值，如果endpoint为true，该值包含于数列中
   num	要生成的等步长的样本数量，默认为50
   endpoint	该值为 true 时，数列中包含stop值，反之不包含，默认是True。
   retstep	如果为 True 时，生成的数组中会显示间距，反之不显示。
   dtype	ndarray 的数据类型

   举例：

   设置起始点为 1 ，终止点为 10，数列个数为 10

   import numpy as np
   a = np.linspace(1,10,10)
   print(a)
   

   [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
   

   设置元素全部是1的等差数列

   import numpy as np
   a = np.linspace(1,1,10)
   print(a)
   

   [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
   

   numpy.logspace： 用于创建一个于等比数列

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

   参数：

   参数	描述
   start	序列的起始值为：base ** start
   stop	序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
   num	要生成的等步长的样本数量，默认为50
   endpoint	该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
   base	对数 log 的底数。
   dtype	ndarray 的数据类型

   举例：

   import numpy as np
   a = np.logspace(0,9,10,base=2)
   print (a)
   

   [  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]
   

NumPy 切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样

简单的举几个例子感感受一下：

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

[2  4  6]

多维数组的索引提取

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])

[[1 2 3]
 [3 4 5]
 [4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5]
 [4 5 6]]

通过 … 来提取

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素

[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

NumPy 高级索引

整数数组索引

获取数组中(0,0)，(1,1)和(2,0)位置处的元素

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

[1  4  5]

获取 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]

import numpy as np 
 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：' )
print (x)
print ('\n')
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print  ('这个数组的四个角元素是：')
print (y)

我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

这个数组的四个角元素是：
[[ 0  2]
 [ 9 11]]

相当于切片是：y = x[ [ [ 0,0 ],[ 0,2] ] , [ [ 3,0 ],[ 3,2] ] ]

可以借助切片 : 或 … 与索引数组组合

import numpy as np
 
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)

[[5 6]
 [8 9]]
[[5 6]
 [8 9]]
[[2 3]
 [5 6]
 [8 9]]

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组

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

我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]


大于 5 的元素是：
[ 6  7  8  9 10 11]

NumPy 广播(Broadcast)

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

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

import numpy as np 
 
a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print (c)

[ 10  40  90 160]

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
print(a + b)

[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

NumPy 迭代数组

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

import numpy as np
 
a = np.arange(6).reshape(2,3)
print ('原始数组是：')
print (a)
print ('\n')
print ('迭代输出元素：')
for x in np.nditer(a):
    print (x, end=", " )
print ('\n')

原始数组是：
[[0 1 2]
 [3 4 5]]


迭代输出元素：
0, 1, 2, 3, 4, 5, 

还可以通过设置参数来指定输出的排序方式

import numpy as np
 
a = np.arange(6).reshape(2,3)
for x in np.nditer(a.T):
    print (x, end=", " )
print ('\n')
 
for x in np.nditer(a.T.copy(order='C')):
    print (x, end=", " )
print ('\n')

0, 1, 2, 3, 4, 5, 

0, 3, 1, 4, 2, 5, 

控制遍历顺序

• for x in np.nditer(a, order='F'):Fortran order，即是列序优先；
• for x in np.nditer(a.T, order='C'):C order，即是行序优先；

修改数组中元素的值

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

原始数组是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


修改后的数组是：
[[  0  10  20  30]
 [ 40  50  60  70]
 [ 80  90 100 110]]

NumPy的数组操作

Numpy 中包含了一些函数用于处理数组，大概可分为以下几类：

• 修改数组形状
• 翻转数组
• 修改数组维度
• 连接数组
• 分割数组
• 数组元素的添加与删除

修改数组形状

numpy.reshape

numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： numpy.reshape(arr, newshape, order=‘C’)

• arr：要修改形状的数组
• newshape：整数或者整数数组，新的形状应当兼容原有形状
• order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。

实例

import numpy as np  
a = np.arange(8) 
print ('原始数组：') 
print (a) print ('\n')  

b = a.reshape(4,2) 
print ('修改后的数组：') print (b)

输出结果如下：

原始数组：
[0 1 2 3 4 5 6 7]

修改后的数组：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

numpy.ndarray.flat

numpy.ndarray.flat 是一个数组元素迭代器，实例如下:

实例

import numpy as np
 
a = np.arange(9).reshape(3,3) 
print ('原始数组：')
for row in a:
    print (row)
 
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
    print (element)

输出结果如下：

原始数组：
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0
1
2
3
4
5
6
7
8

numpy.ndarray.flatten

numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：

ndarray.flatten(order='C')

参数说明：

• order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。

实例

import numpy as np
 
a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('\n')
# 默认按行
 
print ('展开的数组：')
print (a.flatten())
print ('\n')
 
print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))

输出结果如下：

原数组：
[[0 1 2 3]
 [4 5 6 7]]


展开的数组：
[0 1 2 3 4 5 6 7]


以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

numpy.ravel

numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。

该函数接收两个参数：

numpy.ravel(a, order='C')

参数说明：

• order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。

实例

import numpy as np
 
a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('调用 ravel 函数之后：')
print (a.ravel())
print ('\n')
 
print ('以 F 风格顺序调用 ravel 函数之后：')
print (a.ravel(order = 'F'))

输出结果如下：

原数组：
[[0 1 2 3]
 [4 5 6 7]]


调用 ravel 函数之后：
[0 1 2 3 4 5 6 7]


以 F 风格顺序调用 ravel 函数之后：
[0 4 1 5 2 6 3 7]

翻转数组

修改数组维度

连接数组

分割数组

数组元素的添加与删除

NumPy 字符串函数

以下函数用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。

这些函数在字符数组类（numpy.char）中定义。

NumPy 数学函数

NumPy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。

三角函数

NumPy 提供了标准的三角函数：sin()、cos()、tan()。

实例

import numpy as np
 
a = np.array([0,30,45,60,90])
print ('不同角度的正弦值：')
# 通过乘 pi/180 转化为弧度  
print (np.sin(a*np.pi/180))
print ('\n')
print ('数组中角度的余弦值：')
print (np.cos(a*np.pi/180))
print ('\n')
print ('数组中角度的正切值：')
print (np.tan(a*np.pi/180))

输出结果为：

不同角度的正弦值：
[0.         0.5        0.70710678 0.8660254  1.        ]


数组中角度的余弦值：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]


数组中角度的正切值：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
 1.63312394e+16]

arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。

这些函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度。

实例

import numpy as np
 
a = np.array([0,30,45,60,90])  
print ('含有正弦值的数组：')
sin = np.sin(a*np.pi/180)  
print (sin)
print ('\n')
print ('计算角度的反正弦，返回值以弧度为单位：')
inv = np.arcsin(sin)  
print (inv)
print ('\n')
print ('通过转化为角度制来检查结果：')
print (np.degrees(inv))
print ('\n')
print ('arccos 和 arctan 函数行为类似：')
cos = np.cos(a*np.pi/180)  
print (cos)
print ('\n')
print ('反余弦：')
inv = np.arccos(cos)  
print (inv)
print ('\n')
print ('角度制单位：')
print (np.degrees(inv))
print ('\n')
print ('tan 函数：')
tan = np.tan(a*np.pi/180)  
print (tan)
print ('\n')
print ('反正切：')
inv = np.arctan(tan)  
print (inv)
print ('\n')
print ('角度制单位：')
print (np.degrees(inv))

输出结果为：

含有正弦值的数组：
[0.         0.5        0.70710678 0.8660254  1.        ]


计算角度的反正弦，返回值以弧度为单位：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


通过转化为角度制来检查结果：
[ 0. 30. 45. 60. 90.]


arccos 和 arctan 函数行为类似：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]


反余弦：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


角度制单位：
[ 0. 30. 45. 60. 90.]


tan 函数：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
 1.63312394e+16]


反正切：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


角度制单位：
[ 0. 30. 45. 60. 90.]

舍入函数

numpy.around() 函数返回指定数字的四舍五入值。

numpy.around(a,decimals)

参数说明：

• a: 数组
• decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

实例

import numpy as np
 
a = np.array([1.0,5.55,  123,  0.567,  25.532])  
print  ('原数组：')
print (a)
print ('\n')
print ('舍入后：')
print (np.around(a))
print (np.around(a, decimals =  1))
print (np.around(a, decimals =  -1))

输出结果为：

原数组：
[  1.      5.55  123.      0.567  25.532]


舍入后：
[  1.   6. 123.   1.  26.]
[  1.    5.6 123.    0.6  25.5]
[  0.  10. 120.   0.  30.]

numpy.floor()

numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。

实例

import numpy as np
 
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print ('提供的数组：')
print (a)
print ('\n')
print ('修改后的数组：')
print (np.floor(a))

输出结果为：

提供的数组：
[-1.7  1.5 -0.2  0.6 10. ]


修改后的数组：
[-2.  1. -1.  0. 10.]

numpy.ceil()

numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。

实例

import numpy as np
 
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  ('提供的数组：')
print (a)
print ('\n')
print ('修改后的数组：')
print (np.ceil(a))

输出结果为：

提供的数组：
[-1.7  1.5 -0.2  0.6 10. ]


修改后的数组：
[-1.  2. -0.  1. 10.]

NumPy 算术函数

numpy.reciprocal()

numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。

函数里可以传入参数是数组

numpy.power()

numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

参数可以传入两个相等长度的数组

import numpy as np 
 
a = np.array([10,100,1000])  
print ('我们的数组是；')
print (a)
print ('\n') 
print ('调用 power 函数：')
print (np.power(a,2))
print ('\n')
print ('第二个数组：')
b = np.array([1,2,3])  
print (b)
print ('\n')
print ('再次调用 power 函数：')
print (np.power(a,b))

输出的结果：

我们的数组是；
[  10  100 1000]


调用 power 函数：
[    100   10000 1000000]


第二个数组：
[1 2 3]


再次调用 power 函数：
[        10      10000 1000000000]

numpy.mod()

numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

参数可以传入两个相等长度的数组

NumPy 统计函数

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。 函数说明如下：

numpy.amin() 和 numpy.amax()

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

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

import numpy as np 
 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 amin() 函数：')
print (np.amin(a,1))
print ('\n')
print ('再次调用 amin() 函数：')
print (np.amin(a,0))
print ('\n')
print ('调用 amax() 函数：')
print (np.amax(a))
print ('\n')
print ('再次调用 amax() 函数：')
print (np.amax(a, axis =  0))

我们的数组是：
[[3 7 5]
 [8 4 3]
 [2 4 9]]


调用 amin() 函数：
[3 3 2]


再次调用 amin() 函数：
[2 4 3]


调用 amax() 函数：
9


再次调用 amax() 函数：
[8 7 9]

参数：

print (np.amin(a,1))：a：是传的数组 1：代表行，0 代表列

numpy.ptp()

numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

import numpy as np 
 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 ptp() 函数：')
print (np.ptp(a))
print ('\n')
print ('沿轴 1 调用 ptp() 函数：')
print (np.ptp(a, axis =  1))
print ('\n')
print ('沿轴 0 调用 ptp() 函数：')
print (np.ptp(a, axis =  0))

我们的数组是：
[[3 7 5]
 [8 4 3]
 [2 4 9]]


调用 ptp() 函数：
7


沿轴 1 调用 ptp() 函数：
[4 5 7]


沿轴 0 调用 ptp() 函数：
[6 3 6]

numpy.median()

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

import numpy as np 
 
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 median() 函数：')
print (np.median(a))
print ('\n')
print ('沿轴 0 调用 median() 函数：')
print (np.median(a, axis =  0))
print ('\n')
print ('沿轴 1 调用 median() 函数：')
print (np.median(a, axis =  1))

我们的数组是：
[[30 65 70]
 [80 95 10]
 [50 90 60]]


调用 median() 函数：
65.0


沿轴 0 调用 median() 函数：
[50. 90. 60.]


沿轴 1 调用 median() 函数：
[65. 80. 60.]

numpy.mean()

numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。

算术平均值是沿轴的元素的总和除以元素的数量。

import numpy as np 
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 mean() 函数：')
print (np.mean(a))
print ('\n')
print ('沿轴 0 调用 mean() 函数：')
print (np.mean(a, axis =  0))
print ('\n')
print ('沿轴 1 调用 mean() 函数：')
print (np.mean(a, axis =  1))

我们的数组是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]


调用 mean() 函数：
3.6666666666666665


沿轴 0 调用 mean() 函数：
[2.66666667 3.66666667 4.66666667]


沿轴 1 调用 mean() 函数：
[2. 4. 5.]

numpy.average()

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

import numpy as np 
 
a = np.array([1,2,3,4])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 average() 函数：')
print (np.average(a))
print ('\n')
# 不指定权重时相当于 mean 函数
wts = np.array([4,3,2,1])  
print ('再次调用 average() 函数：')
print (np.average(a,weights = wts))
print ('\n')
# 如果 returned 参数设为 true，则返回权重的和  
print ('权重的和：')
print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))

我们的数组是：
[1 2 3 4]


调用 average() 函数：
2.5


再次调用 average() 函数：
2.0


权重的和：
(2.0, 10.0)

也可以用于处理对维数组

标准差

标准差是一组数据平均值分散程度的一种度量。

标准差是方差的算术平方根。

标准差公式如下：

std = sqrt(mean((x - x.mean())**2))

如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且再求其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。

import numpy as np 
 
print (np.std([1,2,3,4]))

1.1180339887498949

方差

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。

换句话说，标准差是方差的平方根。

import numpy as np
 
print (np.var([1,2,3,4]))

1.25

NumPy 排序、条件刷选函数

NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。

numpy.sort()

numpy.sort(a, axis, kind, order)

参数说明：

• a: 要排序的数组
• axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
• kind: 默认为’quicksort’（快速排序）
• order: 如果数组包含字段，则是要排序的字段

import numpy as np  
 
a = np.array([[3,7],[9,1]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 sort() 函数：')
print (np.sort(a))
print ('\n')
print ('按列排序：')
print (np.sort(a, axis =  0))
print ('\n')
# 在 sort 函数中排序字段 
dt = np.dtype([('name',  'S10'),('age',  int)]) 
a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
print ('我们的数组是：')
print (a)
print ('\n')
print ('按 name 排序：')
print (np.sort(a, order =  'name'))

我们的数组是：
[[3 7]
 [9 1]]


调用 sort() 函数：
[[3 7]
 [1 9]]


按列排序：
[[3 1]
 [9 7]]


我们的数组是：
[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]


按 name 排序：
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]

numpy.argsort()

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

import numpy as np 
 
x = np.array([3,  1,  2])  
print ('我们的数组是：')
print (x)
print ('\n')
print ('对 x 调用 argsort() 函数：')
y = np.argsort(x)  
print (y)
print ('\n')
print ('以排序后的顺序重构原数组：')
print (x[y])
print ('\n')
print ('使用循环重构原数组：')
for i in y:  
    print (x[i], end=" ")

我们的数组是：
[3 1 2]


对 x 调用 argsort() 函数：
[1 2 0]


以排序后的顺序重构原数组：
[1 2 3]


使用循环重构原数组

1 2 3

numpy.lexsort()

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

import numpy as np 
 
nm =  ('raju','anil','ravi','amar') 
dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
ind = np.lexsort((dv,nm))  
print ('调用 lexsort() 函数：') 
print (ind) 
print ('\n') 
print ('使用这个索引来获取排序后的数据：') 
print ([nm[i]  +  ", "  + dv[i]  for i in ind])

调用 lexsort() 函数：
[3 1 0 2]


使用这个索引来获取排序后的数据：
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

上面传入 np.lexsort 的是一个tuple，排序时首先排 nm，顺序为：amar、anil、raju、ravi 。综上排序结果为 [3 1 0 2]。

既是先将含有nm的元素进行排序，在排序其他的元素

msort、sort_complex、partition、argpartition

numpy.argmax() 和 numpy.argmin()

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

numpy.nonzero()

numpy.nonzero() 函数返回输入数组中非零元素的索引。

numpy.where()

numpy.where() 函数返回输入数组中满足给定条件的元素的索引。

numpy.extract()

numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。

NumPy 线性代数

NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能，可以看看下面的说明：

NumPy IO

Numpy 可以读写磁盘上的文本数据或二进制数据。

NumPy 为 ndarray 对象引入了一个简单的文件格式：npy。

npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。

常用的 IO 函数有：

• load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。

• savez() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。

• loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)

numpy.save()

numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中。

numpy.save(file, arr, allow_pickle=True, fix_imports=True)

参数说明：

• file：要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。
• arr: 要保存的数组
• allow_pickle: 可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。
• fix_imports: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据。

import numpy as np 
 
a = np.array([1,2,3,4,5]) 
 
# 保存到 outfile.npy 文件上
np.save('outfile.npy',a) 
 
# 保存到 outfile2.npy 文件上，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上
np.save('outfile2',a)

save()保存的文件使用load()加载

b = np.load('outfile.npy')  
print (b)

[1 2 3 4 5]

np.savez

numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中。

numpy.savez(file, *args, **kwds)

参数说明：

• file：要保存的文件，扩展名为 .npz，如果文件路径末尾没有扩展名 .npz，该扩展名会被自动加上。
• args: 要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, …　。
• kwds: 要保存的数组使用关键字名称。

import numpy as np 
 
a = np.array([[1,2,3],[4,5,6]])
b = np.arange(0, 1.0, 0.1)
c = np.sin(b)
# c 使用了关键字参数 sin_array
np.savez("runoob.npz", a, b, sin_array = c)
r = np.load("runoob.npz")  
print(r.files) # 查看各个数组名称
print(r["arr_0"]) # 数组 a
print(r["arr_1"]) # 数组 b
print(r["sin_array"]) # 数组 c

['sin_array', 'arr_0', 'arr_1']
[[1 2 3]
 [4 5 6]]
[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
[0.         0.09983342 0.19866933 0.29552021 0.38941834 0.47942554
 0.56464247 0.64421769 0.71735609 0.78332691]

savetxt()

savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。

np.loadtxt(FILENAME, dtype=int, delimiter=' ')
np.savetxt(FILENAME, a, fmt="%d", delimiter=",")

参数 delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。

import numpy as np 
 
a = np.array([1,2,3,4,5]) 
np.savetxt('out.txt',a) 
b = np.loadtxt('out.txt')  
 
print(b)

[1. 2. 3. 4. 5.]