数据分析 大数据之路 四 numpy 2

 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 ('
')
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]

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.]

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

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

原数组：
[-1.7  1.5 -0.2  0.6 10. ]

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

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

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

　　

原数组：
[-1.7  1.5 -0.2  0.6 10. ]


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

NumPy 算术函数

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

add() 加法

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))

第一个数组：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]

第二个数组：
[10 10 10]

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

　　

subtract()减法

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.subtract(a,b))

第一个数组：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]

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

下边不再演示

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

reciprocal(） 倒数

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     ]

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]

　　

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 统计函数

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))
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]

　　

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.]

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.]

标准差和方差

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

1.118033988749895
1.25

　　

NumPy 排序、条件筛选函数

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)]

　　

 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

　　

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 副本和视图

 副本或深拷贝

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

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]]

浅拷贝

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() 函数：
139630489172528
a 赋值给 b：
[0 1 2 3 4 5]
b 拥有相同 id()：
139630489172528
修改 b 的形状：
[[0 1]
 [2 3]
 [4 5]]
a 的形状也修改了：
[[0 1]
 [2 3]
 [4 5]]

NumPy 线性代数

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

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]]

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

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

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

2

　　

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]]

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

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

-2.0000000000000004

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

考虑以下线性方程：

$left{egin{matrix}
x+y+z=6
& \ 2y+5z=-4
& \ 2x+5y-z=27
end{matrix} ight.$

$egin{bmatrix}
1&1 &1 \
0&2 &5 \
2& 5& -1
end{bmatrix}
egin{bmatrix}
x\
y\
z
end{bmatrix}
=egin{bmatrix}
6\
-4\
27
end{bmatrix}$

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.]]

　　

持久化（将这个对象保存到硬盘上）

 使用  H5PY ,PICKLE

# -*- coding: utf-8 -*-
# 斌彬电脑
# @Time : 2019-03-28  上午 9:31

import pickle
import numpy as np

A = 1000

def pickle_dump():
    """
    数据持久化
    :return:
    """
    with open('sampk.pkl', 'wb') as f:
        # 生成二维的随机数
        array = np.random.randn(A, A)
        pickle.dump(array, f)
        print('持久化{}'.format(array))


def pickle_load():
    """
    反持久化
    :return:
    """
    with open('sampk.pkl', 'rb') as f:
        array = pickle.load(f)
        print('反持久化{}'.format(array))


if __name__ == '__main__':
    pickle_dump()
    pickle_load()

　　

# -*- coding: utf-8 -*-
# 斌彬电脑
# @Time : 2019-03-28  下午 4:53

import numpy as np
import h5py
import numpy as np
import h5py
'''h5py就是以 k, v 的形式存储'''

N = 1000

def pickle_serialization():
    """
    持久化
    :return:
    """
    with h5py.File("sample.h5", "w") as hf:
        array = np.random.randn(N, N)
        # 可以示为生成个 group 的文件夹
        group = hf.create_group("group")
        # dataset 可以示为是个列表
        group.create_dataset("dataset", data=array)
        print("持久化: {}".format(array))


def pickle_deserialization():
    """
    反持久化
    :return:
    """
    with h5py.File("sample.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]].value))


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

　　

 

 

 

 

 

 

阵乘积；