Numpy矩阵

一、矩阵创建

1、使用 np.mat、np.asmatrix 创建矩阵

np.mat 和 np.asmatrix 是相同的

代码实现：

import numpy as np

# 可以使用np.mat  np.asmatrix  np.bmat 来创建矩阵
# np.mat  和 np.asmatrix 是相同
# 可以将特殊字符串转化为矩阵
m1 = np.mat('1 2 3;4 5 6;7 8 9')
print('m1:\n', m1)
print('m1 类型：\n', type(m1))  # <class 'numpy.matrix'>

# 也可以将列表嵌套转化为矩阵
m1 = np.mat([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print('m1:\n', m1)
print('m1 类型：\n', type(m1))  # <class 'numpy.matrix'>

# 也可以将二维数组转化为矩阵
m1 = np.mat(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
print('m1:\n', m1)
print('m1 类型：\n', type(m1))  # <class 'numpy.matrix'>

# 也有属性
print('m1 的 维度：', m1.ndim)  # 矩阵的维度只能是2维
print('m1  的形状：', m1.shape)
print('m1 的元素个数：', m1.size)
print('m1 的元素的类型：', m1.dtype)
print('m1 的单个元素的大小：', m1.itemsize)

2、使用 np.bmat 来组合矩阵

代码实现:

# 使用np.bmat 来创建矩阵 ---组合矩阵
# 可以使用bmat 将二维数组转化为矩阵
m1 = np.bmat(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
print('m1:\n', m1)
print('m1 类型：\n', type(m1))

# m1 = np.bmat([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  # 错误的  # np.bmat不可以将列表嵌套转化为矩阵
# m1 = np.bmat('1 2 3;4 5 6;7 8 9')  # 错误的 # np.bmat不能将特殊字符串转化为矩阵

# 组合大矩阵
# 创建两个小数组
arr1 = np.zeros((2, 2))
arr2 = np.ones((2, 2))
print('arr1:\n', arr1)
print('arr2:\n', arr2)
# 组合
m1 = np.bmat('arr1 arr2;arr2 arr1')
print('m1:\n', m1)
print('m1 的类型:\n', type(m1))

# 矩阵的索引 ---在矩阵里面索引的时候使用下标不降低维度
# 矩阵的索引 ---索引之后的结果还是矩阵  ---2维的
print('获取m1 的里面第0 行元素：', m1[0, :])

二、矩阵运算及矩阵属性

1、矩阵相加减

代码实现：

import numpy as np

# 创建矩阵
m1 = np.mat([[1, 3], [2, 1]])
m2 = np.asmatrix([[1, 2], [5, 6]])
print('m1:\n', m1)
print('m1 类型:\n', type(m1))
print('m2:\n', m2)
print('m2 类型:\n', type(m2))

# 矩阵的相加减
# 1、同型矩阵  2、矩阵对应位置元素相加减
print('m1 + m2:\n', m1 + m2)
print('m1 - m2:\n', m1 - m2)

2、矩阵与数相乘

代码实现：

import numpy as np

# 创建矩阵
m1 = np.mat([[1, 3], [2, 1]])
m2 = np.asmatrix([[1, 2], [5, 6]])
print('m1:\n', m1)
print('m1 类型:\n', type(m1))
print('m2:\n', m2)
print('m2 类型:\n', type(m2))
# 矩阵与数相乘
# 矩阵对应位置元素 与数进行相乘
print('m1 * 3 :\n', m1 * 3)

3、矩阵相乘

代码实现：

import numpy as np

# 创建矩阵
m1 = np.mat([[1, 3], [2, 1]])
m2 = np.asmatrix([[1, 2], [5, 6]])
print('m1:\n', m1)
print('m1 类型:\n', type(m1))
print('m2:\n', m2)
print('m2 类型:\n', type(m2))
# 矩阵与矩阵相乘
# 左矩阵的列 = 右矩阵的行，才能进行相乘 ---->生成一个左矩阵行、右矩阵列的矩阵
# m1 --->(2,2)
# m2 --->(2,2)
print('矩阵相乘：\n', m1 * m2)
print('矩阵相乘：\n', np.matmul(m1, m2))
print('矩阵相乘：\n', np.dot(m1, m2))

# 矩阵对应位置元素相乘
# # 1、同型矩阵 2、对应位置元素相乘
print('矩阵对应位置元素相乘：\n', np.multiply(m1, m2))

矩阵特有属性:

代码实现：

import numpy as np

# 创建矩阵
m1 = np.mat([[1, 3], [2, 1]])
m2 = np.asmatrix([[1, 2], [5, 6]])
print('m1:\n', m1)
print('m1 类型:\n', type(m1))
print('m2:\n', m2)
print('m2 类型:\n', type(m2))
# 矩阵的性质
# 矩阵的转置 ---行、列互换
print('矩阵的转置：\n', m1.T)

# 矩阵的逆  -->数学里面--方阵
# 如果可逆---才能求出逆 ---不然报错或者出现警告
print('矩阵的逆：\n', m1.I)
# # 矩阵 * 矩阵的逆  = E
print('矩阵*矩阵的逆：\n', np.matmul(m1, m1.I))

# 创建一个矩阵
m3 = np.mat('1 2 3;4 1 2')
print('m3:\n', m3)
#
print('矩阵的逆：\n', m3.I)
print('矩阵* 矩阵的逆：\n', np.matmul(m3, m3.I))

# 矩阵的共轭转置 ---先共轭再转置
print('m1 的共轭转置：\n', m1.H)

# 可以通过np.mat　np.asmatrix将数组转化为矩阵
# 也可以通过 矩阵.A 将矩阵转化为数组
# 矩阵的视图
print('矩阵的视图：\n', m1.A)
print('矩阵的视图：\n', type(m1.A))  # <class 'numpy.ndarray'>

三、数组的全通用函数

全称通用函数（universalfunction），是一种能够对数组中所有元素进行操作的函数，以 Numpy 数组作为输出，因此不需要对数组每个元素都操作，比math库中的函数操作效率更高

四则运算： 加（+）、减（-）、乘（*）、除（/）、幂（**），数组间的四则运算表示对每个数组中的元素分别进行四则运算，所以形状必须相同

代码实现：

import numpy as np

# 全通用函数 ---对数组中的每一个元素都进行运算的函数
# 以整个数组为对象的一起运算 --->输出数组

# 要求：同型数组
# 创建数组
arr1 = np.array([[1, 2], [4, 3]])
arr2 = np.array([[2, 4], [2, 1]])
print('arr1:\n', arr1)
print('arr2:\n', arr2)
print('*' * 100)

# 1、四则运算 ---+ - * / **  # -----> 对应位置元素进行运算
print('数组相加：\n', arr1 + arr2)  # 对应位置元素进行相加
print('数组相减：\n', arr1 - arr2)  # 对应位置元素进行相减
print('数组相乘：\n', arr1 * arr2)  # 对应位置元素进行相乘
print('数组相除：\n', arr1 / arr2)  # 对应位置元素进行相除
print('数组相幂：\n', arr1 ** arr2)  # 对应位置元素进行求幂

比较运算： >、<、==、>=、<=、!=，比较运算返回的结果是一个布尔数组，每个元素为每个数组对 应元素的比较结果

代码实现：

# 要求：同型数组
# 创建数组
arr1 = np.array([[1, 2], [4, 3]])
arr2 = np.array([[2, 4], [2, 1]])
print('arr1:\n', arr1)
print('arr2:\n', arr2)
print('*' * 100)
# 2、比较运算 --- < > <= >= == !=  # ---->对应位置进行比较，返回的是bool数组
print('arr1 >= arr2 :\n', arr1 >= arr2)
print('arr1 != arr2 :\n', arr1 != arr2)
print('arr1 == arr2 :\n', arr1 == arr2)

逻辑运算： np.any 函数表示逻辑“or”，np.all函数表示逻辑“and”，运算结果返回布尔值

代码实现：

# 要求：同型数组
# 创建数组
arr1 = np.array([[1, 2], [4, 3]])
arr2 = np.array([[2, 4], [2, 1]])
print('arr1:\n', arr1)
print('arr2:\n', arr2)
print('*' * 100)
# 3、逻辑运算 --- np.all  np.any  --->返回的值 为bool值
# &  --> 所有为True  --->结果才为True    ----> np.all
# |  --> 只要有一个为True ---->结果就为True  ---->np.any
print('all :\n', np.all(arr1 >= arr2))
print('all :\n', np.all(arr1 != arr2))

print('any :\n', np.any(arr1 >= arr2))
print('any :\n', np.any(arr1 == arr2))

# 注意： 一定要区分开 比较运算返回bool数组，逻辑运算返回bool值

# 比较运算 --->返回bool数组 --->一般和索引连用--->筛选满足条件的数据

# 逻辑运算  ---> 用于判断

四、数组的广播机制

广播（broadcasting）是指不同形状的数组之间执行算术运算的方式

需要遵循 4 个原则

（1）让所有输入数组都向其中 shape 最长的数组看齐，shape 中不足的部分都通过在 前面加 1 补齐

（2）输出数组的 shape 是输入数组 shape 的各个轴上的最大值

（3）如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为 1 时，这个 数组能够用来计算，否则出错

（4）当输入数组的某个轴的长度为 1 时，沿着此轴运算时都用此轴上的第一组值

代码实现：

import numpy as np

# 广播机制

# 创建形状不相同的数组
arr1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  # (3,3)
arr2 = np.array([1, 1, 1])
# (3,)  ---> arr2 向 arr1 看齐，在arr2 shape前面加1补齐  ---> (1,3)
# arr2 --->[[1 1 1]]
print('arr1:\n', arr1)
print('arr2:\n', arr2)

#
# arr3 = np.array([[1, 2], [2, 1]])  # (2,2)  (3,3) ---> 规则2 ---(3,3)
arr3 = np.array([[1], [2], [3]])  # (3,1)   arr1(3,3) --->规则2--- (3,3)
# 规则3  判定是否能运算 ，规则1、2、4 是运算的过程
#
print('arr1 + arr2 :\n', arr1 + arr2)

print('arr1 + arr3 :\n', arr1 + arr3)

# arr1 --->shape (1,2,3,4,5,5,6,7)
# arr2 ---> shape (1,5,1,6,7) # 可以运算


# arr2 ---->shape (1,2,3,1,2,3,1,1,5)
# arr1  --->shape (1,2,3,3,4,1) # 可以运算


# arr1 --->shape (2,3,2)
# arr2 --->shape (3,3) # 不可以

五、Numpy 读写文件

Numpy 文件读写主要有二进制的文件读写和文件列表形式的数据读写两种形式

1、二进制文件

save 函数是以二进制的格式保存数据

load 函数是从二进制的文件中读取数据

savez 函数可以将多个数组保存到一个文件中

存储时可以省略扩展名，但读取时不能省略扩展名

代码实现：

import numpy as np

# 二进制、文本文件

# 创建数组
arr = np.arange(16).reshape((4, 4))
print('arr:\n', arr)

# 以二进制形式来保存单个数组
# 参数1：文件的路径+名称，此时需要注意，可以省略文件后缀名，默认保存为.npy为结尾的文件
# 参数2： 需要保存的数组
np.save('./arr', arr)
print('保存成功')

# 加载.npy文件
# 参数：.npy文件的路径+名称，注意：不能省略后缀名
# 返回保存的数组
arr = np.load('./arr.npy')
print('arr:\n', arr)

# 再创建一个数组
arr1 = np.ones((2, 3), dtype=np.int32)
print('arr1:\n', arr1)

# # 将多个数组保存为二进制文件
# 以 key:value 的这种映射关系来进行保存
# 参数1 ：保存路径 + 名称，此时注意,可以省略文件后缀，默认保存为.npz文件
# 后续的参数： 需要保存的数组
np.savez('./arr', arr, arr1)
print('保存成功')

# # 加载.npz数据
# # 参数：文件的路径+名称，此时不能省略文件后缀名
fp = np.load('./arr.npz')
print('fp:\n', fp)  # <numpy.lib.npyio.NpzFile object at 0x000000000297EF08>
#
# # 先获取到保存时映射关系的key
# # 遍历
for k in fp:
    print(k)
# # --->在保存的时候，设置的key 为 arr_0, arr_1
# # 如果存在多个数组保存，设置key 为 arr_0,arr_1,...,arr_n
x = fp['arr_0']
y = fp['arr_1']
print('x:\n', x)
print('y:\n', y)

# 存在问题：在同时保存大量数组之后，无法区分各个数组的功能
# ---->在保存数组的时候，显式的指定各个数组在.npz中key的名称

# 指定key值来保存数组到.npz中去
# x,y --->保存的数组的key
np.savez('./arr_key', x=arr, y=arr1)
# print('保存成功')

# 加载arr_key.npz文件
fp = np.load('./arr_key.npz')
print('fp:\n', fp)  # <numpy.lib.npyio.NpzFile object at 0x000000000299F348>

# 遍历
for k in fp:
    print(k)
#
# # 加载
x = fp['x']
y = fp['y']
print('x:\n', x)
print('y:\n', y)

# 也可以以文本形式进行保存
arr = np.arange(16).reshape((4, 4))
print('arr:\n', arr)

2、读取文本格式的数据（TXT CSV 格式）

savetxt 函数是将数组写到某种分隔符隔开的文本文件中

loadtxt 函数执行的是把文件加载到一个二维数组中

genfromtxt 函数面向的是结构化数组和缺失数据

代码实现：

import numpy as np
# 也可以以文本形式进行保存
arr = np.arange(16).reshape((4, 4))
print('arr:\n', arr)

# 以文本形式来保存数组
# 参数1：保存的路径+名称
# 参数2： 需要保存的数组
# fmt='%.18e' -->保存的格式，默认科学计数法
# delimiter=' ' --->数据之间的分隔符，默认为空格
np.savetxt('./arr.txt', arr, fmt='%d', delimiter=',')
print('保存成功')

# 加载保存为文本形式的数组
# 参数1：路径+名称
# dtype ：加载出来的类型
# delimiter : 分隔符，保存的是什么，指定是什么
data = np.loadtxt('./arr.txt', dtype=np.int32, delimiter=',')
print('data:\n', data)

# 加载 --可以加载含有缺失的数据，会给定一个与原数据不相符的占位数据
data = np.genfromtxt('./arr.txt', dtype=np.int32, delimiter=',')
print('data:\n', data)

# numpy --->科学计算
# 数据分析、挖掘、机器学习中用到的较多的文件：excel文件、csv文件、txt文件

六、数组排序

1、直接排序

sort 函数是最常用的排序方法。 arr.sort()

sort 函数也可以指定一个 axis 参数，使得 sort 函数可以沿着指定轴对数据集进行排序，axis=1为沿横轴排序；axis=0为沿纵轴排序

代码实现：

import numpy as np

# # 创建数组
arr = np.array([3, 5, 1, 6, 2])
#
# # 直接排序 --直接对原数组进行排序---升序排序
arr.sort()
print('arr:\n', arr)
# 创建数组
arr = np.array([[3, 1, 2],
                [2, 5, 4],
                [4, 0, 3]])
print('arr:\n', arr)

# 对二维数组排序
# axis = -1 ,默认在列的方向上排序
# 升序排序  ---注意：数组排序---（各自飞）
arr.sort()
print('排序之后的结果为：\n', arr)

# 在行的方向进行升序排序
arr.sort(axis=0)
print('排序之后的结果为：\n', arr)

2、间接排序

argsort 函数返回值为重新排序值的下标。 arr.argsort()

代码实现：

# 创建数组
arr = np.array([3, 5, 1, 6, 2])
# argsort --返回排序的下标
sorted_res = arr.argsort()

print('sorted_res:\n', sorted_res)
# 创建数组
arr = np.array([[3, 1, 2],
                [2, 5, 4],
                [4, 0, 3]])
print('arr:\n', arr)
# 间接排序  ----排序之后的下标
sorted_res = arr.argsort()

print('sorted_res:\n', sorted_res)

七、数组去重与重复

1、数组去重

通过 unique 函数可以找出数组中的唯一值并返回已排序的结果

应用场景： 统计类别种类数目；信息清洗，去掉重复数据，例如班级学员统计，可以依据电话号码等属性进行去重

代码实现：

import numpy as np

# 统计的数据 --->查找出现的不同的数据都有哪些---需要对数据进行去重

# 创建数组
arr = np.array([2, 2, 2, 3, 3, 3, 1, 1, 1, 0, 0, 0])
#
# 对数组进行去重  ---np.unique ---对数组排序功能
#
unique_arr = np.unique(arr)
#
print('去重之后的arr:\n', unique_arr)

# 英文数组
arr = np.array(['bob', 'sony', 'tom', 'tom', 'sony', 'jery', 'jery', 'bob'])
#
# 对英文数组去重  --排序 ---ascii编码排序
unique_arr = np.unique(arr)
#
print('去重之后的结果为：\n', unique_arr)

# 中文数组
arr = np.array(['小花', '小华', '小化', '小米', '小明', '小智', '小花', '小华', '小化', '小米', '小明', '小智'])
# 对中文数组去重 ---能去重，也能排序 --->先unicode编码，再排序
unique_arr = np.unique(arr)
#  小化 ---\u5c0f\u5316
#  小华 ---\u5c0f\u534e
#
print('去重之后的结果为：\n', unique_arr)

2、数组重复

可以使用 np.tile 和 np.repeat 来进行数组重复

这两个函数的主要区别在于，tile 函数是对数组进行重复操作，repeat 函数是对数组 中的每个元素进行重复操作

代码实现：

import numpy as np
# 重复数组
# 可以使用np.tile  np.repeat来重复数组
# 创建数组
arr = np.array([[1, 2], [3, 4]])
print('arr:\n', arr)

# # np.tile
# # 注意：以整个数组为重复对象
res_arr = np.tile(arr, 2)  # 列的维度复制
res_arr1 = np.tile(arr, (2,2)) # 在对应维度进行复制
res_arr2 = np.tile(arr, (2, 2, 2))
print('res_arr:\n', res_arr)
print('res_arr1:\n', res_arr1)
print('res_arr2:\n', res_arr2)

# 以整行 为重复对象 进行复制
res_arr = np.repeat(arr, 2, axis=0)
# 以整列为 重复对象进行复制
res_arr1 = np.repeat(arr, 2, axis=1)
# 如果不指定 重复的轴，默认将数组展开，以单个元素为重复对象，进行按照列的方向重复
res_arr2 = np.repeat(arr, 2)
print('res_arr:\n', res_arr)
print('res_arr:\n', res_arr1)
print('res_arr:\n', res_arr2)

八、数组的统计分析

当 axis=0 时，表示沿着纵轴计算，当axis=1时，表示沿着横轴计算，默认时计算一个总值

代码实现：

import numpy as np

# sum max  mean  std  var min  argmin argmax cumsum cumprod

# 创建数组
arr = np.array([[5, 8, 4],
                [4, 9, 3],
                [6, 7, 5]])
print('arr:\n', arr)

# 统计指标可以使用 np.指标
# 当axis = 0 时， 按照行的方向，向下统计
print('按照行的方向，进行统计arr 的和', np.sum(arr, axis=0))
print('按照行的方向，进行统计arr 的平均值', np.mean(arr, axis=0))
print('按照行的方向，进行统计arr 的最大值', np.max(arr, axis=0))
print('按照行的方向，进行统计arr 的最大值下标', np.argmax(arr, axis=0))
print('按照行的方向，进行统计arr 的最小值', np.min(arr, axis=0))
print('按照行的方向，进行统计arr 的最小值下标', np.argmin(arr, axis=0))

# 反应的数据的离散程度，方差越大，数据越散乱，方差越小，数据越集中
#  var = ((x1 - mean)^2 + (x2 - mean)^2 + ... + (xn - mean)^2) / n
print('按照行的方向，进行统计arr 的方差', np.var(arr, axis=0))

# 反应的数据的离散程度，标准差越大，数据越散乱，标准差越小，数据越集中
# std = 根号下 方差
print('按照行的方向，进行统计arr 的标准差', np.std(arr, axis=0))

print('按照行的方向，进行统计arr 的累计和：\n', np.cumsum(arr, axis=0))

print('按照行的方向，进行统计arr 的累计积：\n', np.cumprod(arr, axis=0))

# 同理 ---当axis = 1 时，也可以对arr 沿着列的方向向右统计各个指标

# 若 axis = None 时，将arr 按照行优先顺序，展开为一维数组，然后再进行统计指标
print('当 axis= None 时，对arr 进行累计求和：\n', np.cumsum(arr, axis=None))  # [ 5 13 17 21 30 33 39 46 51]

# 还存在一种统计指标的方式： arr.指标
print('按照行的方向，进行统计arr的累计和：\n', arr.cumsum(axis=0))

九、案例：英雄联盟离职分析

英雄联盟是目前非常火的一款网络游戏，里面的有许多英雄在峡谷里面任职，以下为各 个英雄的任职信息，请根据以下信息进行价值挖掘

需求：

（1）员工的平均薪资为多少？

（2）公司任职最久的员工是谁？

（3）员工的平均工作年限是多少？

（4）员工总体流失率是多少？

（5）员工整体满意程度如何？

代码实现：

import numpy as np

# 1、加载数据
fp = np.load('./lol_data.npz')
# # 遍历 --获取key
for k in fp:
    print(k)

#  通过k 来加载 真实保存的数组
columns = fp['columns']
data = fp['data']
print('columns:\n', columns)
print('data:\n', data)
print('data:\n', data.shape)
print('*' * 100)

# 2、对数据进行去重
data = np.unique(data, axis=0)
print('去重之后的data:\n', data)
print('去重之后的data:\n', data.shape)

# ---> columns 中的 每一个元素 对应是 data 中各列的名称、说明

# （1）员工的平均薪资为多少？
# # 直接获取到 薪资 这一列，然后.mean()
# # 先获取 薪资
salary = data[:, 4]
print('salary:\n', salary)
# # 将 salary 转化为 数值类型
# # 修改类型 ---astype 来进行修改
salary = salary.astype(np.int32)
print('salary的类型：\n', salary.dtype)
# # 对薪资 求mean
salary_mean = np.mean(salary, axis=0)
print('salary_mean：\n', salary_mean)

# （2）公司任职最久的员工是谁？
# # 获取 工龄 的最大值 --->工作最久的年限 --->员工的姓名
# # 先获取工龄
work_year = data[:, -3]
print('work_year:\n', work_year)
# # 将工龄转化为 数值型
work_year = work_year.astype(np.int32)
print('work_year 类型：', work_year.dtype)
# # 获取工龄的最大值
max_work_year = work_year.max(axis=0)
print('max_work_year:\n', max_work_year)
# # 根据最大的工作年限 ---来查找该员工的姓名---bool数组
mask = data[:, -3] == str(max_work_year)
print('mask:\n', mask)
# bool数组索引
worker_name = data[mask, 1]
print('任职最久的员工为：', worker_name)

# （3）员工的平均工作年限是多少？
# 先获取到工龄  ----然后求取均值
# 先获取工龄
work_year = data[:, -3]
print('work_year:\n', work_year)
# # 将工龄转化为 数值型
work_year = work_year.astype(np.int32)
print('work_year 类型：', work_year.dtype)
# # 求取均值
work_year_mean = np.mean(work_year, axis=0)
print('平均工作年限：', work_year_mean)

# （4）员工总体流失率是多少？
# # 流失率 = 离职 / 总人数
# # 先计算出离职的人数 ---bool数组
mask = data[:, -1] == '离职'  # True满足条件的 ---离职的
# # 筛选离职的 数据
out_work = data[mask, :]
print('离职的数据：\n', out_work)
# 获取离职人数
out_worker_num = out_work.shape[0]
print('离职人数：', out_worker_num)
# # 后计算出总人数
all_worker_num = data.shape[0]
# # 相除
print('离职率为：', out_worker_num / all_worker_num)

# （5）员工整体满意程度如何？
# 整体的满意程度--->各个员工满意程度的平均值
# 先获取 满意度 这一列数据
satisfaction = data[:, -2]
print('各个员工的满意度：\n', satisfaction)
# 先转化为数值类型
satisfaction = satisfaction.astype(np.int32)
print('satisfaction 类型：', satisfaction.dtype)
# 求取均值
satisfaction_mean = np.mean(satisfaction, axis=0)

print('平均满意度：', satisfaction_mean)