0x24 numpy基础，线性代数

Posted 2021-12-30 liu247

01numpy的使用

　　1.numpy的两个基本元素　　n维数组和矩阵

lst = [[1,3,8],[2,4,7]]
arr = np.array(lst,dtype=float)
mat = np.mat(lst,dtype=float)
print(‘arr type:, \nmat type:‘.format(type(arr),type(mat)))
arr_add = arr + mat
# narray 加矩阵　还是的等于矩阵
print(‘\nType:\nValue:\n‘.format(type(arr_add),arr_add))

# arr type:<class ‘numpy.ndarray‘>,
# mat type:<class ‘numpy.matrix‘>

# Type:<class ‘numpy.matrix‘>
# Value:
# [[ 2. 6. 16.]
# [ 4. 8. 14.]]

　　２.元素的基本属性

print(‘维度数：‘,arr.ndim)
print(‘每维的形状：‘,arr.shape)
print(‘元素个数：‘,arr.size)
print(‘数据类型：‘,arr.dtype)
print(‘每个字符元素占的字节：‘,arr.itemsize)

# 维度数： 2
# 每维的形状： (2, 3)
# 元素个数： 6
# 数据类型： float64
# 每个字符元素占的字节： 8

02切片和索引

ten = np.arange(10)
print(ten)
# 太基础了就不写了
ten.shape = (2,5) #转化为二维数组
print(‘1:\n‘,ten[1,1])  #二维数组的索引　第一数是行，第二个数是列
print(‘2:\n‘,ten[0])  #第一行的所有元素
print(‘3:\n‘,ten[1,:]) #第一行的所以元素
print(‘4:\n‘,ten[1:,:]) #出第一行外，所有剩下的元素
print(‘5:\n‘,ten[:,::2]) #所有的行，隔一列取一个数字
print(‘6:\n‘,ten[:,[0,3,1]]) # 所有行，用数组选定制定列

０３变形与切片

　　１.变形

lst = [[1,3,8],[2,4,7]]
arr = np.array(lst,dtype=float)
a1 = arr.reshape([1,6]) #　　变形
a2 = arr.reshape([3,2]) # 　变形２
a3 = arr.reshape([2,-1]) # -1的意思就是让他自己去做
print(‘a1:\n‘,a1)
print(‘a2:\n‘,a2)
print(‘a3:\n‘,a3)
print(‘ndim: shape:‘.format(a1.ndim,a1.shape))
print(‘ndim: shape:‘.format(a2.ndim,a2.shape))

a1:
 [[1. 3. 8. 2. 4. 7.]]
a2:
 [[1. 3.]
 [8. 2.]
 [4. 7.]]
a3:
 [[1. 3. 8.]
 [2. 4. 7.]]
ndim:2 shape:(1, 6)
ndim:2 shape:(3, 2)

　　2.统计－－聚类函数

print(arr)
print(‘column min‘,arr.min(axis=0))
print(‘column max‘,arr.max(axis=0))
print(‘row mean‘,arr.mean(axis=1))
print(‘row sum‘,arr.sum(axis=1))
print(‘row product‘,arr.prod(axis=1)) #这个轴上的乘积
print(‘column cumsum:\n‘,arr.cumsum(axis=1)) # 不断叠加的数　相当与累加

# 结果
[[1. 3. 8.]
 [2. 4. 7.]]
column min [1. 3. 7.]
column max [2. 4. 8.]
row mean [4.         4.33333333]
row sum [12. 13.]
row product [24. 56.]
column cumsum:
 [[ 1.  4. 12.]
 [ 2.  6. 13.]]

０４矩阵运算

　　1.加减除　都是对应位置进行运算(注意两个矩阵的shape要一样)

　　2.乘法　分为点乘和数乘

　　　　并且在narrayn类型和matrix类型的操作是不一样的

 1 arr = np.array([[1,3,8],[2,4,7]])
 2 arr2 = arr * 2
 3 print(type(arr),type(arr2))
 4 print(‘array multiply:\n‘,np.multiply(arr,arr2))
 5 print(‘array multiply:\n‘,arr * arr2)　# 默认为普通的乘法
 6 print(‘array dot:\n‘,arr.dot(arr2.T)) #矩阵的乘法
 7 # <class ‘numpy.ndarray‘> <class ‘numpy.ndarray‘>
 8 # array multiply:
 9 #  [[  2  18 128]
10 #  [  8  32  98]]
11 # array multiply:
12 #  [[  2  18 128]
13 #  [  8  32  98]]
14 # array dot:
15 #  [[148 140]
16 #  [140 138]]

narray

 1 # matrix 
 2 mat2 = mat*2
 3 print(type(mat),‘\n‘,type(mat2))
 4 print(‘matrix multipy:\n‘,np.multiply(mat,mat2))
 5 print(‘matrix multipy:\n‘,mat * mat.T)
 6 print(‘matrix dot:\n‘,mat.dot(mat2.T))
 7 # <class ‘numpy.matrix‘> 
 8 #  <class ‘numpy.matrix‘>
 9 # matrix multipy:
10 #  [[  2.  18. 128.]
11 #  [  8.  32.  98.]]
12 # matrix multipy:
13 #  [[74. 70.]
14 #  [70. 69.]]
15 # matrix dot:
16 #  [[148. 140.]
17 #  [140. 138.]]

matrix

　　3.特殊的矩阵

　　　　注意点－－＞zeros和ones的u参数都是一个元组

　　　　　　　　　　eye只带一个参数就是单位矩阵　和identity是一样的　

　　　　　　　　　　但是eye也可以带两个参数－－＞可以看成标准型矩阵

 1 print(‘1:\n‘,np.zeros((2,3))) # 零矩阵
 2 print(‘2:\n‘,np.ones((3,2))) # 一矩阵
 3 print(‘3:\n‘,np.eye(3))  # 单位矩阵
 4 print(‘4:\n‘,np.eye(3,2))  # 变形的单位矩阵
 5 print(‘5:\n‘,np.identity(3))  
 6 # 1:
 7 #  [[0. 0. 0.]
 8 #  [0. 0. 0.]]
 9 # 2:
10 #  [[1. 1.]
11 #  [1. 1.]
12 #  [1. 1.]]
13 # 3:
14 #  [[1. 0. 0.]
15 #  [0. 1. 0.]
16 #  [0. 0. 1.]]
17 # 4:
18 #  [[1. 0.]
19 #  [0. 1.]
20 #  [0. 0.]]
21 # 5:
22 #  [[1. 0. 0.]
23 #  [0. 1. 0.]
24 #  [0. 0. 1.]]

０５实用方法　　

# 点的均分
np.linspace(1,9,100) # 1 到　9 之间生成100个点
# 对数据进行按区间统计
data = np.random.randn(5)
print(data)
hist,bin_edges = np.histogram(data,[-5,0,5.0])
print(hist,bin_edges)
# [-0.42084482  0.63806664  0.36249437  0.87166671 -0.16333273]
# [2 3] [-5.  0.  5.]

# 使用searchsorted方法查找要插入的位置
import random
data = sorted(random.sample(range(100),6))
print(data)
np.searchsorted(data,8)
# [2, 5, 62, 73, 80, 98]
# 2

# 随机产生具有正太分布的数组
print(np.random.randn(2,3))
#　合并数据
a = np.ones((2,2))
b = np.eye(2)
print(np.vstack((a,b))) # 纵向合并 
print(np.hstack((a,b))) # 横向合并
# [[-1.01588455  1.29143552 -0.96335368]
#  [-0.22734122 -1.99529277 -0.83173721]]
# [[1. 1.]
#  [1. 1.]
#  [1. 0.]
#  [0. 1.]]
# [[1. 1. 1. 0.]
#  [1. 1. 0. 1.]]

０６　结语

numpy对自己实现数据挖掘算法或者是阅读成熟的源码都很重要，numpy里还有一个十分强大的线性代数的库linalg.好好学习吧！