学习笔记——Numpy基本操作（二）

为了方便我把本文介绍的一些函数全部列举了
数学函数
三角函数：sin()、cos()、tan()
numpy.around()
numpy.floor()
numpy.ceil()

算术函数
加减乘除: add()，subtract()，multiply() 和 divide()
numpy.reciprocal()
numpy.power()
numpy.mod()
numpy.remainder()

统计函数
numpy.amin() 和 numpy.amax()
numpy.median()
numpy.mean()
标准差和方差：np.std和np.var numpy.sort()

排序、条件刷选函数
numpy.sort()
numpy.argsort()
numpy.where()

副本和视图 副本或深拷贝

线性代数 numpy.dot()
numpy.vdot()
numpy.inner()
numpy.matmul ()
numpy.linalg.det()
numpy.linalg.solve()

Numpy 线性代数

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

函数	描述
dot	两个数组的点积，即元素对应相乘
vdot	两个向量的点积
inner	两个数组的内积
matmul	两个数组的矩阵积
determinant	数组的行列式
solve	求解线性矩阵方程
inv	计算矩阵的乘法逆矩阵

• numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘 积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组 a 的最后一维上的所有元素与数组 b 的倒数第二位上的所有元素 的乘积和：dot(a,b)[i,j,k,m] = sum(a[i,j,:]*b[k,:,m])。
• numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的 共轭复数会用于计算。 如果参数是多维数组，它会被展开。
• numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最 后一个轴上的和的乘积。
• numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正 常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引 的矩阵的栈，并进行相应广播。
• numpy.linalg.det() 函数计算输入矩阵的行列式。行列式在线性代数中是非 常有用的值。 它从方阵的对角元素计算。 对于2×2 矩阵，它是左上和右 下元素的乘积与其他两个的乘积的差。
• numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解。
• numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。
• 逆矩阵（inverse matrix）：设 A 是数域上的一个 n 阶矩阵，若在相同数域 上存在另一个 n 阶矩阵 B，使得： AB=BA=E ，则我们称 B 是 A 的逆矩阵， 而 A 则被称为可逆矩阵。

---

持久化

1、h5py

一个 HDF5 文件是一种存放两类对象的容器：dataset 和 group. Dataset 是类似于数
组的数据集，而 group 是类似文件夹一样的容器，存放 dataset 和其他 group。在使用
h5py 的时候需要牢记一句话：groups 类比词典，dataset 类比 Numpy 中的数组。

HDF5 的 dataset 虽然与 Numpy 的数组在接口上很相近，但是支持更多对外透明的
存储特征，如数据压缩，误差检测，分块传输。

详细文档：http://docs.h5py.org/en/stable/quick.html

示例：

import numpy as np
import h5py

N=1000
def pickle_serialization():   #序列化
    with h5py.File('data.h5','w') as hf:
        array = np.random.randn(N,N)
        group = hf.create_group('group')   #group相当于文件夹
        group.create_dataset('dataset',data=array)   #dataset相对于具体文件
        print('Serialization:{}'.format(array))

def pickle_deserialization():   #反序列化
    with h5py.File('data.h5','r') as hf:
        for key in hf.keys():
            group = hf.get(key)
            for item in group.items():
                print('after deserialization:{}'.format(group[item[0]]))

if __name__ == '__main__':
    pickle_serialization()
    pickle_deserialization()

---

2、cPickle

在 python 中，一般可以使用 pickle 类来进行 python 对象的序列化，而 cPickle 提供了一个更快速简单的接口，如 python 文档所说的：“cPickle – A faster pickle”。

cPickle 可以对任意一种类型的 python 对象进行序列化操作，比如 list，dict，甚至是一个类的对象等。而所谓的序列化，我的粗浅的理解就是为了能够完整的保存并能够完全可逆的恢复。

详细文档：https://docs.python.org/2.2/lib/node61.html

示例：

import pickle
import numpy as np

N=1000
def pickle_serialization():    #序列化
    with open('data.pkl','wb') as f:
        array = np.random.randn(N,N)
        pickle.dump(array,f)
        print('Serialization:{}'.format(array))

def pickle_deserialization():   #反序列化
    with open('data.pkl','rb') as f:
        array = pickle.load(f)
        print('Deserialization:{}'.format(array))

if __name__ == '__main__':
    pickle_serialization()
    pickle_deserialization()

---

基本操作

NumPy 数学函数

1、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 ('')
print ('数组中角度的余弦值：')
print (np.cos(a*np.pi/180))
print ('')
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]

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

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

--------------
执行结果：
原数组：
[  1.      5.55  123.      0.567  25.532]

舍入后：
[  1.   6. 123.   1.  26.]

3、numpy.floor() 返回数字的下舍整数

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

-----------
执行结果：
提供的数组：
[-1.7  1.5 -0.2  0.6 10. ]

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

4、numpy.ceil() 返回数字的上入整数

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

-------------------
执行结果：
提供的数组：
[-1.7  1.5 -0.2  0.6 10. ]

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

---

NumPy 算术函数

1、NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()

import numpy as np 
 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print ('第一个数组：')
print (a)
print ('')
print ('第二个数组：')
b = np.array([10,10,10])  
print (b)
print ('')
print ('两个数组相加：')
print (np.add(a,b))
print ('')
print ('两个数组相减：')
print (np.subtract(a,b))
print ('')
print ('两个数组相乘：')
print (np.multiply(a,b))
print ('')
print ('两个数组相除：')
print (np.divide(a,b))

-------------------------
执行结果：
第一个数组：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]

第二个数组：
[10 10 10]

两个数组相加：
[[10. 11. 12.]
 [13. 14. 15.]
 [16. 17. 18.]]

两个数组相减：
[[-10.  -9.  -8.]
 [ -7.  -6.  -5.]
 [ -4.  -3.  -2.]]

两个数组相乘：
[[ 0. 10. 20.]
 [30. 40. 50.]
 [60. 70. 80.]]

两个数组相除：
[[0.  0.1 0.2]
 [0.3 0.4 0.5]
 [0.6 0.7 0.8]]

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

import numpy as np 
 
a = np.array([0.25,  1.33,  1,  100])  
print ('我们的数组是：')
print (a)
print ('')
print ('调用 reciprocal 函数：')
print (np.reciprocal(a))

---------------------
执行结果：
我们的数组是：
[  0.25   1.33   1.   100.  ]

调用 reciprocal 函数：
[4.        0.7518797 1.        0.01     ]

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

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

----------------------
执行结果：
我们的数组是；
[  10  100 1000]

调用 power 函数：
[    100   10000 1000000]

第二个数组：
[1 2 3]

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

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

import numpy as np
 
a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print ('第一个数组：')
print (a)
print ('')
print ('第二个数组：')
print (b)
print ('')
print ('调用 mod() 函数：')
print (np.mod(a,b))
print ('')
print ('调用 remainder() 函数：')
print (np.remainder(a,b))

--------------------------------
执行结果：
第一个数组：
[10 20 30]

第二个数组：
[3 5 7]

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

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

---

NumPy 统计函数

1、numpy.amin() 和 numpy.amax()

import numpy as np 
 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print ('我们的数组是：')
print (a)
print ('')
print ('调用 amin() 函数：')
print (np.amin(a,1))            #1 ：axis=1轴
print ('')
print ('再次调用 amin() 函数：')
print (np.amin(a,0))
print ('')
print ('调用 amax() 函数：')
print (np.amax(a))
print ('')
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]

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

import numpy as np 
 
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
print ('我们的数组是：')
print (a)
print ('')
print ('调用 median() 函数：')
print (np.median(a))
print ('')
print ('沿轴 0 调用 median() 函数：')
print (np.median(a, axis =  0))
print ('')
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.]

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

import numpy as np 
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print ('我们的数组是：')
print (a)
print ('')
print ('调用 mean() 函数：')
print (np.mean(a))
print ('')
print ('沿轴 0 调用 mean() 函数：')
print (np.mean(a, axis =  0))
print ('')
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.]

4、标准差和方差

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

------------------------------
执行结果：
1.118033988749895
1.25

---

NumPy 排序、条件刷选函数

1、numpy.sort() 函数返回输入数组的排序副本

import numpy as np  
 
a = np.array([[3,7],[9,1]])  
print ('我们的数组是：')
print (a)
print ('')
print ('调用 sort() 函数：')
print (np.sort(a))
print ('')
print ('按列排序：')
print (np.sort(a, axis =  0))
print ('')
# 在 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 ('')
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)]

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

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

-------------------------------------
执行结果：
我们的数组是：
[3 1 2]

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

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

使用循环重构原数组：
1
2
3

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

import numpy as np 
 
x = np.arange(9.).reshape(3,  3)  
print ('我们的数组是：')
print (x)
print ( '大于 3 的元素的索引：')
y = np.where(x >  3)  
print (y)
print ('使用这些索引来获取满足条件的元素：')
print (x[y])

-----------------------------------
执行结果：
我们的数组是：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
大于 3 的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
使用这些索引来获取满足条件的元素：
[4. 5. 6. 7. 8.]

---

NumPy 副本和视图

1、副本或深拷贝

import numpy as np 
 
a = np.array([[10,10],  [2,3],  [4,5]])  
print ('数组 a：')
print (a)
print ('创建 a 的深层副本：')
b = a.copy()  
print ('数组 b：')
print (b)
# b 与 a 不共享任何内容  
print ('我们能够写入 b 来写入 a 吗？')
print (b is a)
print ('修改 b 的内容：')
b[0,0]  =  100  
print ('修改后的数组 b：')
print (b)
print ('a 保持不变：')
print (a)

------------------------------
执行结果：
数组 a：
[[10 10]
 [ 2  3]
 [ 4  5]]
创建 a 的深层副本：
数组 b：
[[10 10]
 [ 2  3]
 [ 4  5]]
我们能够写入 b 来写入 a 吗？
False
修改 b 的内容：
修改后的数组 b：
[[100  10]
 [  2   3]
 [  4   5]]
a 保持不变：
[[10 10]
 [ 2  3]
 [ 4  5]]

2、浅拷贝

import numpy as np 
 
a = np.arange(6)  
print ('我们的数组是：')
print (a)
print ('调用 id() 函数：')
print (id(a))
print ('a 赋值给 b：')
b = a 
print (b)
print ('b 拥有相同 id()：')
print (id(b))
print ('修改 b 的形状：')
b.shape =  3,2  
print (b)
print ('a 的形状也修改了：')
print (a)

-----------------------------------------
执行结果：
我们的数组是：
[0 1 2 3 4 5]
调用 id() 函数：
4640120544
a 赋值给 b：
[0 1 2 3 4 5]
b 拥有相同 id()：
4640120544
修改 b 的形状：
[[0 1]
 [2 3]
 [4 5]]
a 的形状也修改了：
[[0 1]
 [2 3]
 [4 5]]

---

NumPy 线性代数

NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能。

1、numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积

import numpy.matlib
import numpy as np
 
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.dot(a,b))

-------------------------------------
执行结果：
[[37 40]
 [85 92]]

2、numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开

import numpy as np 
 
a = np.array([[1,2],[3,4]]) 
b = np.array([[11,12],[13,14]]) 
 
# vdot 将数组展开计算内积
print (np.vdot(a,b))

-----------------------
执行结果：
130

3、numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积

import numpy as np 
 
print (np.inner(np.array([1,2,3]),np.array([0,1,0])))

---------------------
执行结果：
2

4、numpy.matmul() 函数返回两个数组的矩阵乘积

import numpy.matlib 
import numpy as np 
 
a = [[1,0],[0,1]] 
b = [[4,1],[2,2]] 
print (np.matmul(a,b))

------------------------------
执行结果：
[[4 1]
 [2 2]]

5、numpy.linalg.det() 函数计算输入矩阵的行列式

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

---------------------
执行结果：
-2.0000000000000004

6、numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解

import numpy as np 
 
a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 
 
print ('数组 a：')
print (a)
 
print ('矩阵 b：')
b = np.array([[6],[-4],[27]]) 
print (b)
 
x = np.linalg.solve(a,b) 
print ('求解')
print (x)

----------------------------
执行结果：
数组 a：
[[ 1  1  1]
 [ 0  2  5]
 [ 2  5 -1]]
矩阵 b：
[[ 6]
 [-4]
 [27]]
求解
[[ 5.]
 [ 3.]
 [-2.]]