numpy

0、作用

使用numpy&pandas使得数据分析中计算非常快，比python自带的字典和列表快很多，因为这俩模块使用C语言编写的。应用到了矩阵的运算，使用C语言实现，更快。

1、安装

直接在终端使用命令

pip install numpy

安装完成即可

2、numpy基本属性

基本属性包括：将列表转换为numpy的array，查看array的维度、形状、总元素个数

import numpy as np #一般习惯重命名为np
# 将列表转换为numpy的矩阵
array = np.array([[1,2,3],[2,3,4]])
print(array)
# 维度
print('number of dimation: ',array.ndim)
# 形状
print('shape:',array.shape)
# 总共多少个元素在矩阵中
print('size:',array.size)

3、创建

创建的方法有：

1. 直接传入列表
2. 通过zeros()方法生成全为0的矩阵
3. 通过ones()方法生成全为1的矩阵
4. 通过empty()方法生成全为0的矩阵
5. 通过arange()方法生成有序array
6. 使用reshape指定形状，注意，元素个数可以变成指定的形状否则报错
7. linspace分段
8. 使用random模块，生成随机的。随机数位于0到1之间

import numpy as np
# 1,直接传入列表，使用的type指定数据类型，比如float32，几位数字需要根据精度需求来确定
# 位数越大，精度越高但同时占用空间越大
a = np.array([[2,3,4],[3,4,5]],dtype=np.float32)
# 打印出来，和列表的差别就是，没有逗号
print(a)
print(a.dtype)

# 2,直接生成全部为0的矩阵,需要在参数中传入形状（用一个括号包着)
# 如果不指定数据类型，zeros默认为float64
b = np.zeros((3,4))
print(b)
# 同理，生成全为1的，使用ones方法即可
b = np.ones((4,5),dtype=np.int16)
print(b)

# 3,empty,相当于生成全为0的
c = np.empty((3,4))
print(c)

# 4，生成有序，和python中的arange相同，指定区间（左闭右开），指定步长
# 步长为2,10到20之间
c = np.arange(10,21,2)
print(c)

# 5，使用reshape指定形状，注意，元素个数可以变成指定的形状否则报错
c = np.arange(12).reshape((3,4))
print(c)

# 6，linspace分段，在闭区间1到10中生成5个点，平均分成4段
a = np.linspace(0,10,5)
print(a)

# 7、使用random模块，生成随机的。随机数位于0到1之间
a = np.random.random((2,4))
print(a)

4、运算

1. 加法、减法、指数运算、三角函数运算、布尔值运算。都是对每个元素都进行运算
2. 矩阵乘法
3. • 逐个元素相乘
   • 使用dot方法矩阵相乘（线性代数的知识）
4. 求和，求最大值最小值，都是返回一个指定的元素
5. 求指定维度的和、最大最小值，需要根据axis指定维度

import numpy as np
a = np.array([10,20,30,40])
b = np.arange(4)
print(a,b)
# 1、减法
print(a-b)
# 2、加法
print(a+b)
# 3、指数
print(a**2)
# 4、三角函数运算
# print(np.sin(a),np.cos(a),np.tan(a))
# 5、布尔值
print(b)
print(b<3)
print(b==3)

############矩阵###########
a = np.array([[10,20],[30,45]])
b = np.arange(4).reshape((2,2))
print(a)
print(b)
# 乘法，逐个相乘
print(a*b)
# 乘法，矩阵相乘，使用np.dot或者a.dot(b)
print(np.dot(a,b))
print(a.dot(b))

# 随机生成一个矩阵
a = np.random.random((2,4))
print(a)
# 求和，或者写成a.sum()
print(np.sum(a))
# 最大值
print(np.max(a))
# 最小值
print(np.min(a))
# 求指定维度的和，最大最小值
# axis为1，就是将维度为1的元素累加，该维度消失，只剩下维度为0的行
print(np.sum(a,axis=1))
print(np.max(a,axis=1))
print(np.min(a,axis=0))
# 另一种写法
print(a.min(axis=0))
# 总结，axis的值为求和的维度，运算之后该维度消失

5、运算2

1. 求最小最大值索引
2. 求平均值，指定维度求平均值
3. 求中位数
4. 累加，第n个元素为原矩阵前n个元素的和
5. 累差，原矩阵相邻元素之间的差值，列数减一
6. 找出非0的元素，返回的值是多个表示非零元素的维度数组，数组拼接即可得到非零元素的索引值
7. 排序，按照最小的维度排序，对于矩阵就是对行内的列元素排序
8. 转置矩阵

import numpy as np
A = np.arange(2,14).reshape((3,4))
print(A)
# 最小值索引，两种写法都可
print(np.argmin(A))
print(A.argmin())
# 最大值索引
print(A.argmax())
# 求平均值
print(A.mean())
# 也可以指定维度
print(np.mean(A,axis=0))
print(np.average(A))
# 不能这样使用average
# print(A.average())

# 求中位数,也是只能np.median
print(np.median(A))
# 累加,第n个元素为原矩阵前n个元素的和
print(np.cumsum(A))
# 累差，原矩阵相邻元素之间的差值，列数减一了，因为n个元素有n-1个差值
print(np.diff(A))
# 找出非零元素，返回维度的数组
print(np.nonzero(A))

# 排序，最小的那个维度的数进行排序。如果是矩阵，就是行内的每列元素进行排序
B = np.arange(14,2,-1).reshape((3,4))
print(B)
# 不会改变原矩阵的值
print(np.sort(B))

# 矩阵的转置，行变成列，列变成行
print(np.transpose(B))
print(B.T)
print((B.T).dot(B))

# clip，所有大于9的数都变成9，小于5的数都变成5,5到9之间的数不变
print(B)
print(np.clip(B,5,9))

6、索引

1. 对于多维的索引，索引号都放在一个中括号中，用逗号分割开
2. 切片
3. for迭代，默认迭代矩阵的行

import numpy as np

A = np.arange(3,15).reshape((3,4))
print(A)
print(A[2])
print(A[2][1])
# 多维索引都放在一个中括号中，用逗号分割
print(A[2,1])

# 切片
# 第一维度所有元素，就是原矩阵
print(A[:])
# 第一维度不限定，第二维度索引为1
print(A[:,1])
# 切片限定第二维度（列）
print(A[1,1:3])
print("********************")

# for迭代，默认迭代矩阵的行。就是第一维度
for row in A:
    print(row)
# 迭代矩阵的列，可以通过迭代转置矩阵的列
for col in A.T:
    print(col)
# 迭代每一个元素,flat之后是一个一维的列表
for item in A.flat:
    print(item,end=',')

7、array合并

1. 使用vstack实现多个array上下合并
2. 使用hstack实现多个array水平合并
3. 把一个横向的数列变成纵向的数列
4. 使用concatenate多个array的合并指定合并的维度

import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])

# 上下合并
C = np.vstack((A,B))
print(C)
print(A.shape,C.shape)

# 左右合并（水平合并） horizontal stack
D = np.hstack((A,B))
print(D)
print(A.shape,D.shape)

print("*********************")
# 如何把一个横向的数列变成纵向的数列
A = A[:,np.newaxis]
B = B[:,np.newaxis]
print(A.shape,B.shape)
# 左右合并，hstack和vstack都可以进行多个array的合并
D = np.hstack((A,B,B))
print(D)

# 多个array的合并指定合并的维度，和上面两个不同的就是可以指定合并的维度
# 比如，在第一维度合并，即合并行
C = np.concatenate((A,B,B,A),axis=0)
print(C)
# 合并列
print(np.concatenate((A,B,B,A),axis=1))

8、分割

1. 使用split均等分割
2. 使用array_split不均等分割
3. 使用vsplit和hsplit进行均等分割

import numpy as np

A = np.arange(12).reshape((3,4))
print(A)
# 均等分割，使用split均等分割
print(np.split(A,2,axis=1))
print(np.split(A,3,axis=0))

# 不均等分割，使用array_split
# 这里将四列分为三部分，第一部分为2列，2,3部分为1列
print(np.array_split(A,3,axis=1))
# 使用vsplit和hsplit进行分割
print(np.vsplit(A,3))
print(np.hsplit(A,2))

9、copy和deep copy

1. 通过 = 赋值的变量都指向同一个数据
2. 使用copy方法使复制后两个变量不相关联

import numpy as np
a = np.arange(4)
print(a)
b = a
c = a
d = b
# 目前为止，abcd都是一样
# 这里更改a的值，观察其他变量的改变
a[0]=11
print(a,b,c,d)
print(b is a,c is a,d is a)
# 可以看到，改变了a，bcd都会改变，哪怕是通过b赋值的d
# 同理，改变了bcd任何一个元素，a的值也会改变
# 所以，通过=赋值的变量都是指向同一个数据，是浅拷贝

# 如果想让赋值后的两个变量不相关联，使用copy()方法
e = a.copy()
print(e is a)
a[1]=22
print(a,e)