数据分析粗略了解第一篇

数控分析前三天知识点

矩阵

1 创建一个三阶矩阵：

arr1=np.mat('1 2 3;2 3 4;3 4 5')
arr2 = np.mat('2 3 4;4 5 6;7 8 9')

2矩阵加法
矩阵加法的规则是相加的矩阵必须是同型矩阵，相加时每个位置的元素对应相加

arr3 = arr1+arr2	

3矩阵乘法
矩阵乘法的规则是相乘的矩阵必须是前面的矩阵的列数等于后面矩阵的行数，且矩阵相乘不符合交换律,相乘时，第一个数组的第一行乘以第二个数组的第一列对应元素相乘再相加，得到a11，同理可得其他元素

arr1 = np.mat("1 2 3;2 3 4") #为两行三列
arr2 = np.mat("2 3;3 4 ;4 5") #为三行两列
arr = arr1*arr2

4矩阵转置
所谓矩阵转置就是将矩阵的行变成列，列变成行

arr1 = np.mat("1 2 3;2 3 4")
arr2 = arr1.T
#输出时为:
arr2 = [1 2;2 3; 3 4]

5逆矩阵
首先，要求一个矩阵的逆，就要满足该矩阵对应的行列式的值|A|不为0，然后求出其伴随矩阵A*，
最后得到其逆矩阵为A-1 = A*/|A|
6 矩阵数乘
直接让矩阵和数相乘，结果是每个元素都和这个数相乘

arr1 = np.mat("1 2 3;2 3 4")
arr = 2*arr1

7对应元素相乘
必须是同型矩阵才可以元素相乘，利用multiply方法，得到的结果是每个对应元素相乘

arr1 = np.mat("1 2 3;2 3 4") 
arr2 = np.mat("2 3 5;5 7 8")
arr= np.multiply(arr1,arr2)

8 矩阵的属性

arr1 = np.mat("1 2 3;2 3 4") 
arr1.shape #查看矩阵的结构，返回的是元组类型。二维及以上矩阵元组内的是(行数，列数)，一维矩阵元组内的是元素个数（元素个数,）,逗号必须得有
arr1.size #查看矩阵中元素的个数
arr1.ndim #查看矩阵的维度
arr1.dtype #查看矩阵的类型

数组

数组的所有运算都是对应算素的运算
1创建一个一维数组：

arr1 = np.array([1,2,3,4])

2创建一个二维数组

arr2 = np.array([[1, 2, 3],[0, 1, 2],[2, 3, 1]])

3列向量类型的数组

arr3 = np.array([[1], [2],[3],[4]])

4数组的属性：
一维数组和高阶数组的方法一样

arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([[1, 2, 3],[0, 1, 2],[2, 3, 1]])
#数组的属性
print('一维数组结构：\n', arr1.shape)
print('二维数组结构：\n', arr2.shape)

#数组的大小,返回的是数组内元素的个素
print('一维数组结构：\n', arr1.size)
print('二维数组结构：\n', arr2.size)

#数组的维度
print('一维数组结构：\n', arr1.ndim)
print('二维数组结构：\n', arr2.ndim)

#数组的类型
print('一维数组结构：\n', arr1.dtype)
print('二维数组结构：\n', arr2.dtype)
``
数组的索引
1一维数组的索引
```python
arr1[::-1]#类似于列表的索引，按照倒序排列获取所有的元素组成一个新的元组

2二维数组的切片
类似于把一行看成一个列表，一列也看成一个列表
例如有一个二维数组如下：

arr=[[1,2,3,4,5],
	 [3,4,5,6,7],
	 [2,3,5,3,7],
	 [7,8,9,0,4]
]
arr1 = arr[1::2,2::2]

这个程序输出的结果是：[5 9 7 4]
如果要输出的是固定位置元素，则可以用下面的代码实现

# arr[(元素1行所在位置，元素行2所在位置...),(元素1列所在位置，元素2列所在位置...)]
#取出第一行额2和第三行的5
arr2 = [(0,2),(1,2)] 

3布尔取值
按照python大多数的规定1为True,0为False来说，可以规定按True取值，False不取值
所以有如下方法

mask = np.array([1, 0, 1,0], dtype=np.bool )
arr=np.array([[1,2,3,4],
	 [3,4,5,6],
	 [2,3,5,3],
	 [7,8,9,0]
])
arr1 = arr[mask,mask]

输出结果为[1 5]
原理是：
arr1 = arr[mask,mask]
mask转换为布尔值为[True False True False]
所以第一步输出的值为[[0 2],[02]],组合成元组为[(0,2),(0,2)]
所以arr1 = arr[(0,2),(0,2)] = [ 1 5]

特殊函数创建组
1 arange 类似于python的range

arr = np.arange(1,10,1)

输出结果为[1,2,3,4,5,6,7,8,9]
2等差数列
linspace 主要利用等差数列的an=a1+(n-1)d
linspace(start=a1, stop=an, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

arr7 = np.linspace(2, 5, 5)

输出为2-5之间的5个等差数值

3等比数列
logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None,axis=0):

arr8 = np.logspace(0, 2, 3, base=10.0)

这里输出的是a1=100，a3=102,q=10的等比数列
4 全一数组和全零数组
ones，全一数组，zeros全零数组

arr9 = np.ones((3, 4))
arr10 = np.zeros((3,3))

arr9输出的是三行四列的元素全为1的数组，arr10输出的是3行3列的元素全为0的数组
5单位数组
eye

arr11 = np.eye(3)

输出的是一个三阶的单位矩阵
6对角数组
diag

arr12 = np.diag([1, 2, 3, 4])

输出的是[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]

创建随即数组
用的是random函数
1 创建n个在0~1之间的随机数， 为一维数组

arr13 =np.random.random(10)

输出的是一个一维数组，里面为1,9的随机数，注意不包含10
2创建服从均匀分布的随机数组

arr14 = np.random.rand(10000)

3创建正态分布数组随机数

arr15 = np.random.randn(10000)

4随机整数的生成

np.random.randint(2, 4, size=[2, 5])

矩阵形态变换
1重置数组结构
a 一维变二维：

arr_1 = np.arange(10)
arr_2 = arr_1.reshape((2, 5))

b.展平： 二维变一维

arr_2.ravel()

c、展平方法二：flatten
order=‘C’:表示横向展平； order='F’表示纵向展平；

arr_2.flatten('C') 
arr_2.flatten('F')

d、堆叠方法

arr_3 = np.zeros((3, 4))
arr_4 = np.ones((3, 4))
# 横向堆叠: 行数一样即可；
arr_5 = np.hstack((arr_3, arr_4))
# 纵向堆叠： 列数相同
arr_6 = np.vstack((arr_3, arr_4))

e:数组合并 concatenate

np.concatenate((arr_3, arr_4), axis=0) #沿着axis=0的方向进行拼接
np.concatenate((arr_3, arr_4), axis=1)  # 沿着axis=1轴的方向进行拼接

concatenate与hstack/vstack的区别：
concatenate是严格沿着数组的轴的方向拼接的，一维数组只有一个轴，因此只有一个种拼接方式；
hstack/vstack 不关注有几个轴，只是单纯按照纵向或横向方向堆叠即可，因此一维数组也有两种堆叠方式；

数组的分割

arr8 = np.hsplit(arr5,2) #横向切割，传入的数值必须可以被被分割的数组整除
arr11 = np.hsplit(arr5,[3,7,9]) #横向切割 按照行的方向切割 按照[:3,3:7,7:9,9::]的切片方法切割
arr12 = np.split(arr5,2,axis=1) #按照axis=1方向切割，左右两部分

四则运算

arr17 = np.arange(1,17).reshape((4,4))

arr18 = np.diag([2,3,1,17]) #对角矩阵

arr19 = arr17*arr18 #乘法运算，对应元素相乘

arr20 = arr18/arr17 #除法，对应元素除

arr21 = arr17 ** arr18 #幂运算 对应元素取幂运算

arr22 = arr18%arr17 #取余运算 对应元素取余

arr23 = arr18//arr17 #整除运算，对应元素整除，值为向下取整的数
#比较运算
print(arr18<arr17)

#过滤运算
mask = arr17>8
print(mask)
print(arr17[mask])
#逻辑运算
# a. 逻辑与运算：
# print(np.all(mask))
#b. 逻辑或运算
# print(np.any(mask))

#数组广播运算
#二维数组＋列向量
arr24 = np.array([[1],[2],[3],[4]])
# print(arr17+arr24)
#二维数组+行向量
arr25 = np.array([1,2,3,4])
# print(arr25+arr17)

#特殊方法
# a 排序并修改原数组
arr26 = np.array([21,10,20,8,15,1])
# arr26.sort() #sort没有返回值 默认从小到大排序
# print(arr26)
#b argsort # 有返回值，返回的是排序后的索引，不修改原数组
# arr26.argsort()
# print(arr26.argsort() )

arr27 = np.array([[12,2,10,9],[2,90,25,1]])
# print(arr27)
# print(arr27.sort())
arr27.sort(axis=0) #默认为axis=1
print(arr27)
print(arr27.argsort())