python-numpy--矩阵与数组的操作

最新推荐文章于 2024-03-17 10:00:00 发布

Allbuypy

最新推荐文章于 2024-03-17 10:00:00 发布

阅读量1.6k

点赞数 10

分类专栏： DataAnalysis 文章标签： python numpy 算法矩阵数组

本文链接：https://blog.csdn.net/zyx13513314194/article/details/111568247

版权

DataAnalysis 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、numpy矩阵

安装numpy：pip install numpy

numpy简介
numpy是计算模块，主要有两种类型：数组、矩阵
特点：运算快

1、创建矩阵

mat1 = np.mat("1 2 3;2 3 4;1 2 3")
mat2 = np.mat("1 7; 2 2; 8 2")
mat3 = np.mat("1 2 3;2 3 4;1 2 3")
mat4 = np.mat("1 0 0;0 4 0;0 0 6")
print(mat1)
[[1 2 3]
 [2 3 4]
 [1 2 3]]
print(type(mat1))
<class 'numpy.matrix'>

2、矩阵计算

# 加法运算
print("矩阵加法运算：\n",mat1+mat3)
矩阵加法运算：
 [[2 4 6]
 [4 6 8]
 [2 4 6]]

# 乘法运算
print("矩阵乘法运算：\n",mat1*mat2)
矩阵乘法运算：
 [[29 17]
 [40 28]
 [29 17]]

# 矩阵的转置运算  T
print("矩阵转置：\n",mat1.T)
矩阵转置：
 [[1 2 1]
 [2 3 2]
 [3 4 3]]

# 逆矩阵方法  I
print("逆矩阵：\n",mat4.I)
逆矩阵：
 [[1.         0.         0.        ]
 [0.         0.25       0.        ]
 [0.         0.         0.16666667]]

# 矩阵与数相乘
print("数乘：\n",4*mat4)
数乘：
 [[ 4  0  0]
 [ 0 16  0]
 [ 0  0 24]]

# 矩阵与矩阵的对应元素相乘
print("对应元素相乘的运算：\n",np.multiply(mat1,mat3))
对应元素相乘的运算：
 [[ 1  4  9]
 [ 4  9 16]
 [ 1  4  9]]

二、矩阵属性

矩阵的结构 ----> shape

print("矩阵的结构：\n",mat1.shape)
矩阵的结构：
 (3, 3)

矩阵的元素个数 ----> size

print("矩阵的元素个数：\n",mat1.size)
矩阵的元素个数：
 9

矩阵的元素类型 ----> dtype

print("矩阵元素类型：\n",mat1.dtype)
矩阵元素类型：
 int32

矩阵的维度 ----> ndim

print("矩阵的维度：\n",mat1.ndim)
矩阵的维度：
 2

三、数组的创建

数组的所有运算都是对应元素的运算

1、数组的创建

# 一维的数组
arr1 = np.array([1,2,3,4])
print(arr1)
print(type(arr1)) # numpy下的数组类型
[1 2 3 4]
<class 'numpy.ndarray'>

# 二维的数组
arr2 = np.array([[1,2,3],[0,1,2],[2,3,1]])
print(arr2)
[[1 2 3]
 [0 1 2]
 [2 3 1]]
 
# 列向量类型的数组
arr3 = np.array([[1],[2],[3],[4]])
print(arr3)
[[1]
 [2]
 [3]
 [4]]

2、数组的属性

数组的结构 ----> shape

print("一维数组结构：\n",arr1.shape)
print("二维数组结构：\n",arr2.shape)
一维数组结构：
 (4,)
二维数组结构：
 (3, 3)

数组的元素个数 ----> size

print("数组元素个数：\n",arr1.size)
print("数组元素个数：\n",arr2.size)
数组元素个数：
 4
数组元素个数：
 9

数组的元素类型 ----> dtype

print("一维数组元素类型：\n",arr1.dtype)
print("二维数组元素类型：\n",arr2.dtype)
一维数组元素类型：
 int32
二维数组元素类型：
 int32

数组的维度 ----> ndim

print("一维数组的维度：\n",arr1.ndim)
print("二维数组的维度：\n",arr2.ndim)
一维数组的维度：
 1
二维数组的维度：
 2

3、数组的索引

# 一维数组索引：
arr1[0]
arr1[:3]
arr1[::-1]
array([4, 3, 2, 1])

# 二维数组的索引
print(arr2)

# arr2[行切片,列切片]
arr2[1,2]
arr2[1,1:3]
arr2[0:2,0:2]
[[1 2 3]
 [0 1 2]
 [2 3 1]]
 
 array([[1, 2],
       [0, 1]])

切片的一些例子

arr2[::2,::2]
array([[1, 3],
       [2, 1]])
       
arr2[1:3,1:3]
array([[1, 2],
       [3, 1]])
       
arr2[:2,::2]
array([[1, 3],
       [0, 2]])

不同行不同列(没有规则)的切片

arr2[(0,1,2),(0,1,2)]
array([1, 1, 1])

arr2[(1,0,1),(0,1,2)]
array([0, 2, 2])

arr2[(0,1,2),(2,1,0)]
array([3, 1, 2])

bool取值 ----> 注意：不要行列同时传入bool值，只在行的位置或列的位置传入

mask = np.array([1,0,1],dtype=np.bool)
print(mask)
[ True False  True]

arr2[mask, :2]
array([[1, 2],
       [2, 3]])
       
arr2[:2,mask]
array([[1, 3],
       [0, 2]])
       
arr2[mask,mask]
array([1, 1])

练习：取出数组中大于3的数

arr5 = np.array([1,6,3,4,5])
# 构建一个mask
mask = np.array([0,1,0,1,1],dtype=np.bool)
arr5[mask]
array([6, 4, 5])

4、特殊函数创建数组

（1）arange

# arange ==> 类似以range
arr6 = np.arange(1,10,1)
print(arr6)
[1 2 3 4 5 6 7 8 9] # 是一个数组而不是列表

（2）等差数列：linspace

np.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None,axis=0)

参数说明：

endpoint=True:表示等差数列，在start与stop之间插入n-2个值（n为数值的个数）

endpoint=False:表示等差数列，在start与stop之间插入n-1个值，表示平均分成n份（为线段的个数）

arr7 = np.linspace(1,5,5)  # 从1开始到5结束共五个数，会自动取之间的平均数
print(arr7)
[1. 2. 3. 4. 5.]

（3）等比数列：logspace

arr8 = np.logspace(0,2,3,base=10.0)
print(arr8)
[  1.  10. 100.]

arr8_1 = np.logspace(1,10,10,base=2)
# arr8_1 = np.logspace(np.log10(2),np.log10(1024),10)
print(arr8_1)
[   2.    4.    8.   16.   32.   64.  128.  256.  512. 1024.]

# arr8_2 = np.logspace(1/2,11/2,6,base=9.0)
arr8_2 = np.logspace(1,11,6,base=3)
print(arr8_2)
[3.00000e+00 2.70000e+01 2.43000e+02 2.18700e+03 1.96830e+04 1.77147e+05]

arr8_3 = np.logspace(np.log10(2),np.log10(162),5)
print(arr8_3)
[  2.   6.  18.  54. 162.]

（4）全一数组：ones

arr9 = np.ones((3, 4))
print(arr9)
"""
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
"""

（5）全零数组：zeros

arr10 = np.zeros((3, 3))
print(arr10)
"""
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
"""

（6）单位数组：eye

arr11 = np.eye(3)
print(arr11)
"""
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
"""

（7）对角数组：diag

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

5、创建随机数组

（1）创建n个在0~1之间的随机数，为一维数组

arr13 = np.random.random(10)
print(arr13)
"""
[0.16533666 0.93130472 0.99346775 0.86320579 0.40984664 0.826645750.83127987 0.81813288 0.38185262 0.5596341 ]
"""

（2）创建服从均匀分布的随机数组

# 如在0~1之间分成100份，它的值是由概率生成的大致都接近的数
arr14 = np.random.rand(100)
print(arr14)

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

arr15 = np.random.randn(10000)
# 可以通过图形来感受正态分布的随机数
import matplotlib.pyplot as plt
plt.figure()
plt.hist(arr15, 20)
plt.show()

（4）随机整数的生成

# 参数：low（起始值） <= X < high（结束值）
print(np.random.randint(2, 4, size=[2, 5]))
"""
[[3 3 2 3 3]
 [3 2 2 2 3]]
"""

6、形态变换、重置数组结构

（1）一维数组变为二维数组

arr_1 = np.arange(10)
print(arr_1)  # [0 1 2 3 4 5 6 7 8 9]

arr_2 = arr_1.reshape((2, 5))
print(arr_2)
"""
[[0 1 2 3 4]
 [5 6 7 8 9]]

"""

（2）展平：ravel ----> 二维数组变为一维数组

# 将刚才的二维数组转回一维数组
print(arr_2.ravel())  # [0 1 2 3 4 5 6 7 8 9]

（3）展平方法二：flatten

参数：
order='C'：以行展平,表示横向展平
order='F'：以列展平,表示纵向展平
print(arr_2.flatten('C'))  # [0 1 2 3 4 5 6 7 8 9]
print(arr_2.flatten('F'))  # [0 5 1 6 2 7 3 8 4 9]

（4）堆叠方法

arr_3 = np.zeros((3, 4))
arr_4 = np.ones((3, 4))

横向堆叠，只有一个参数，是个元组，数组需要行数一致

arr_5 = np.hstack((arr_3, arr_4))
print(arr_5)
"""
[[0. 0. 0. 0. 1. 1. 1. 1.]
 [0. 0. 0. 0. 1. 1. 1. 1.]
 [0. 0. 0. 0. 1. 1. 1. 1.]]
"""

# 纵向堆叠，需要满足列数一致
arr_6 = np.vstack((arr_3, arr_4))
print(arr_6)
"""
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
"""

（5）数组合并：concatenate

参数说明：axis=0,纵向合并；axis=1,横向合并，默认axis=0

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

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

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

ar_1 = np.array([1, 2, 3, 4])
ar_2 = np.array([0, 1, 1, 2])

print(np.concatenate((ar_1, ar_2), axis=0))  # [1 2 3 4 0 1 1 2]
print(np.concatenate((ar_1, ar_2), axis=1))  # 会报错

print(np.vstack((ar_1, ar_2)))
"""
[[1 2 3 4]
 [0 1 1 2]]
"""

（6）数组分割：split

横向分割：列索引取值
print(np.hsplit(arr, 4))
"""
[array([[0., 0.],
       [0., 0.],
       [0., 0.]]), array([[0., 0.],
       [0., 0.],
       [0., 0.]]), array([[1., 1.],
       [1., 1.],
       [1., 1.]]), array([[1., 1.],
       [1., 1.],
       [1., 1.]])]
"""

print(np.hsplit(arr, [3,7,9]))
"""[array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]]), array([[0., 1., 1., 1.],
       [0., 1., 1., 1.],
       [0., 1., 1., 1.]]), array([[1.],
       [1.],
       [1.]]), array([], shape=(3, 0), dtype=float64)]  # 因为最后没有数据了，所以是空数组
"""
也可以写成
print(np.hsplit(arr, np.array([3,7,9])))
# 将其分割为2,2,3,1  [2,4,7] 最后不写值就是取值到到最后

# 纵向分割
print(np.vsplit(arr_i, 3))
"""
[array([[0., 0., 0., 0.],
       [0., 0., 0., 0.]]), array([[0., 0., 0., 0.],
       [1., 1., 1., 1.]]), array([[1., 1., 1., 1.],
       [1., 1., 1., 1.]])]
"""

# 沿着指定轴切割
print(np.split(arr_i, 3, axis=0))
"""
[array([[0., 0., 0., 0.],
       [0., 0., 0., 0.]]), array([[0., 0., 0., 0.],
       [1., 1., 1., 1.]]), array([[1., 1., 1., 1.],
       [1., 1., 1., 1.]])]
"""

7、数组运算

注意：数组之间的运算都是对应元素的运算
（1）四则运算：+、-、*、/、**、%

arr17 = np.arange(1, 17).reshape((4, 4))
print(arr17)
arr18 = np.diag([2, 3, 1, 5])
print(arr18)
直接运算即可
print(arr17 + arr18)
"""
[[ 3  2  3  4]
 [ 5  9  7  8]
 [ 9 10 12 12]
 [13 14 15 21]]
"""
# print(arr17 - arr18)
"""
[[-1  2  3  4]
 [ 5  3  7  8]
 [ 9 10 10 12]
 [13 14 15 11]]
"""
# print(arr17 * arr18)
"""
[[ 2  0  0  0]
 [ 0 18  0  0]
 [ 0  0 11  0]
 [ 0  0  0 80]]
"""
# print(arr18 / arr17)
# print(arr17 ** arr18)
# print(arr18 % arr17)

（2）比较运算：< > == <= >= !=

print(arr18 < arr17)  # 就是每个元素之间的比较
"""
[[False  True  True  True]
 [ True  True  True  True]
 [ True  True  True  True]
 [ True  True  True  True]]
"""
取出arr17中大于8的数
定义mask
mask = arr17 > 8
数组可以与值进行比较，是将数组的所有元素与数值进行比较
print(mask)  # 返回值是True或False，
"""
[[False False False False]
 [False False False False]
 [ True  True  True  True]
 [ True  True  True  True]]
"""
print(arr17[mask])  # [ 9 10 11 12 13 14 15 16]

注意：定义好mask后，后边其他数组拿来用时，mask还是之间的mask（mask的True和False并没有改变）。

（3）逻辑运算

a、逻辑与运算：
print(np.all(mask))  # False
b、逻辑或运算：
print(np.any(mask))  # True

（4）数组广播：只有一行或一列才能广播

二维数组 + 列向量
arr19 = np.array([[1], [0], [1], [0]])
print(arr17 + arr19)
"""
[[ 2  3  4  5]
 [ 5  6  7  8]
 [10 11 12 13]
 [13 14 15 16]]
"""

二维数组 + 行向量
arr20 = np.array([0, 1, 0, 1])
print(arr17 + arr20)
"""
[[ 1  3  3  5]
 [ 5  7  7  9]
 [ 9 11 11 13]
 [13 15 15 17]]
"""

（5）特殊方法

a、排序
（一维数组）
arr21 = np.array([21, 10, 20, 8, 15, 1])

排序、并修改原始数组
arr21.sort()
print(arr21)  # [ 1  8 10 15 20 21]

（二维数组）
arr22 = np.array([[12, 2, 10, 9], [2, 90, 25, 1]])
print(arr22)
"""
[[12  2 10  9]
 [ 2 90 25  1]]
"""
arr22.sort()
print(arr22)
"""
[[ 2  9 10 12]
 [ 1  2 25 90]]
"""

arr22.sort(axis=0)  # 0:纵向排序,1:横向排序，不写为横向排序
"""
[[ 2  2 10  1]
 [12 90 25  9]]
"""

b、argsort

注意：argsort返回的值是索引，是原数组元素的索引，然后排好序
如：下方一维数组的返回值，最后为0，那么原数组索引为0的元素就是最大的
	第一个为5，那么原数组索引为5的元素是最小的

（一维数组）
print(arr21.argsort())  # [5 3 1 4 2 0] --> 索引

（二维数组）
print(arr22.argsort(axis=1))
结果为排序前的索引
"""
[[1 3 2 0]
 [3 0 2 1]]
"""
c、去重：unique
去重后整行与整列去重：
axis=0表示对比整行数，如果整行值都相同，则进行去重
axis=1表示对比整列数，如果整列值都相同，则进行去重
默认axis=None，展平排序
注：去重会进行排序，一维数组直接排序，二维数组会比较数组的第一个数，如果第一个数相同会比较第二个数，直到不一样时，进行排序（列去重会比较每一列的第一个数）。

arr = np.array([21,2,21,1,0,1])
np.unique(arr)  # array([ 0,  1,  2, 21])

arr2 = np.array([[1,2,1,2],[0,2,0,2]])
np.unique(arr2)  # 返回的是一个一维数组
np.unique(arr2,axis=0)  # 将每一行数组看成一个整数，当这一行与其他行完全相同时，去掉它
np.unique(arr2,axis=1)  # 将每一列数组看成一个整数，当这一列与其他列完全相同时，去掉它

（6）文件操作

a、二进制文件的生成
np.save('arr',arr3)  # save保存默认为.npy文件,只能保存一个数组

b、读取二进制文件：load
注意：读取时必须是完整的文件名，注意加上后缀名
np.load('arr.npy')

c、多个数组的保存与读取
np.savez('arrz',arr,arr1)  # savez保存默认为.npz文件,可以保存多个数组

data = np.load('arrz.npz')
print(data)  # 是一个对象
print(list(data))  # 查看npzfile下的npy文件：['arr_0', 'arr_1']
# 提取某个值
print(data['arr_0'])

d、.txt文件的保存与读取
np.savetxt('arr2',arr2,fmt='%d'(数字),delimiter=','(以逗号分隔))  # 保存为txt文件
np.loadtxt('arr2',delimiter=',',dtype=‘str’(以字符串类型查看内容))

7、统计分布方法

注意：统计分布方法中都有axis参数可以传入，并且获取每行或者每列时返回的多个值是数组形式的。
（1）最小值

print('获取整个数组中最小的值：\n',arr.min())
print('获取每一行的最小值：\n',arr.min(axis=1))
print('获取每一列的最小值：\n',arr.min(axis=0))

（2）最大值

print('获取整个数组中最大的值：\n',arr.max())
print('获取每一行的最大值：\n',arr.max(axis=1))
print('获取每一列的最大值：\n',arr.max(axis=0))

（3）最小值索引

print(arr.argmin())
print(arr.argmin(axis=1))
print(arr.argmin(axis=0))

（4）最大值索引

print(arr.argmax())
print(arr.argmax(axis=1))
print(arr.argmax(axis=0))

（5）标准差
注意：方差与标准差可以反映数据的分布：当标准差与方差越大，表示数据越分散；当标准差与方法越小，数据越集中
print(“标准差：\n”,arr.std())
print(“标准差：\n”,arr.std(axis=0)) # 一列一列计算
print(“标准差：\n”,arr.std(axis=1)) # 一行一行计算
（6）方差

print("方差：\n",arr.var())
# 也有axis方法

（7）求和

print(arr.sum())
print('按行求和：\n',arr.sum(axis=1))
print('按列求和：\n',arr.sum(axis=0))

（8）平均值

print('平均值：\n',arr.mean())
print('按行求平均值：\n',arr.mean(axis=1))
print('按列求平均值：\n',arr.mean(axis=0))

（9）累计求和
它的返回值是每做一次运算就返回一个值

print('累计求和：\n',arr.cumsum())
#  [ 1  3  7 13 15 17 21 41 44 53 73 78]

（10）累计求积

print('累计求积：\n',arr.cumprod())

四、习题

1、矩阵

在这里插入图片描述
解答：

import numpy as np

# 1.
mat1 = np.mat("1 0 0;0 2 0;0 0 3")
# print(mat1.I)

# 2.
# print(mat1**6)
mat2 = np.mat("4 0 0;0 5 0;0 0 6")
# print(mat1+mat2)
# print(mat1-mat2)
# print(np.multiply(mat1,mat2))

# 3.
"""
AB = A +2B
A = AB - 2B
A = (A-2E)B
B = A·(A-2E)逆
"""
E = np.mat("1 0 0;0 1 0;0 0 1")
A = np.mat("0 3 3;1 1 0;-1 2 3")
# C = A-2E
C = A - 2 * E
D = C.I
B = A * D
# print(B)

# 4.(1)
"""
y代表系数矩阵
x代表未知数矩阵
z代表和矩阵
yx = z
x = z*y逆
"""
y1 = np.mat("1 2 3;2 2 5;3 5 1")
# x = np.mat("x1 x2 x3")
z1 = np.mat("1 ;2 ;3")
y_n1 = y1.I
# print(y_n)
x1 = y_n1 * z1
# print(x)


# (2)
"""
y代表系数矩阵
x代表未知数矩阵
z代表和矩阵
yx = z
x = z*y逆
"""
y2 = np.mat("1 1 1;1 2 4;1 3 9")
z2 = np.mat("2;3;5")
y_n2 = y2.I
x2 = y_n2 * z2
print(x2)

2、数组

在这里插入图片描述
表格格式如上图所示：A、B、C、D、E 分别对应下图中蓝色框内的五个数组, 并且分布为五日对应的销售数据;
每个数组中 0-3 行分别对应地区：福建，浙江，广州，江苏；每列分别代表销售的水果种类；

(1)分别创建 A/B/C/D/E 五个数组；

(2)将上述五个小数组合成大数组，使其成为完整一张表格；

(3)完成如下几个操作：

比较第 1 日，福建省销售水果的情况，并按照销售量大小进行排序；
第 5 日中，苹果在哪个省份比较畅销？
哪些水果在相应省份 2 日比第 1 日卖的好？
计算 5 日内，四种水果分别再四个地区的总销量；
计算 5 日内，哪种水果在某一个地区的销量超过 6500？
如果在江苏上售卖水果，应该选择哪种水果比较好？为什么？

解答

import numpy as np

(1)、分别创建A,B,C,D,E五个数组，还有省份和水果种类数组
address = ['福建','浙江','广东','江苏']
fruits = ['苹果','猕猴桃','枇杷']
A = np.array([[2020, 0, 1779], [4103, 2505, 0], [2861, 1688, 0], [0, 0, 1213]])
B = np.array([[4134, 2012, 0], [2674, 1309, 2658], [0, 0, 4537], [4353, 2600, 4235]])
C = np.array([[3824, 0, 4291], [0, 0, 3636], [4050, 2146, 2137], [1125, 566, 0]])
D = np.array([[4339, 0, 4733], [4571, 3050, 0], [0, 0, 1196], [2864, 1656, 0]])
E = np.array([[0, 0, 2606], [2370, 0, 4481], [1980, 1216, 0], [3671, 0, 4530]])

(2)、将上述五个小数组合成大数组，使其成为完整一张表格
arr = np.array([A, B, C, D, E])
# print(arr)

(3)、完成以下操作
1、比较第1日，福建省销售水果的情况，并按照销售量大小进行排序
arr1 = A[:1, ::]
arr1.sort()
print(arr1)  # [[   0 1779 2020]]

2、第5日中，苹果在哪个省份比较畅销？ ----> 江苏
arr2 = E[::, :1]
print(arr2.argsort(axis=0))
"""
[[0]
 [2]
 [1]
 [3]]
"""
m = arr2.argsort(axis=0)[-1][0]
print(arr2[m])  # [3671]
"""
[[0]  # 福建
 [2]  # 浙江
 [1]  # 广东
 [3]]  # 江苏
"""

3、哪些水果在相应省份2日比第1日卖的好？
# print(B > A)
res = B > A
print(res)
"""
[[ True  True False]
 [False False  True]
 [False False  True]
 [ True  True  True]]
"""
for i in range(4):  # 省份
    for j in range(3):  # 种类
        if res[i][j]:  # 如果res的值为True
            print(address[i]+'的'+fruits[j]+'第2日比第1日卖的好')
"""
福建的苹果第2日比第1日卖的好
福建的猕猴桃第2日比第1日卖的好
浙江的枇杷第2日比第1日卖的好
广东的枇杷第2日比第1日卖的好
江苏的苹果第2日比第1日卖的好
江苏的猕猴桃第2日比第1日卖的好
江苏的枇杷第2日比第1日卖的好
"""

4、计算5日内，四种水果分别在四个地区的总销量
G = (A+B+C+D+E)
print(G)
"""
[[14317  2012 13409]
 [13718  6864 10775]
 [ 8891  5050  7870]
 [12013  4822  9978]]
"""

5、计算5日内，哪种水果在某一地区的销量超过6500？
print(G > 6500)
"""
[[ True False  True]
 [ True  True  True]
 [ True False  True]
 [ True False  True]]
"""

6、如果在江苏售卖水果，应该选择哪种水果比较好？为什么？
choice_foods = G[3].argsort()[-1]
for i in range(3):
    if choice_foods == i :
        print('卖'+fruits[i]+'比较好，因为卖的最多')
# 卖苹果比较好，因为卖的最多

3、练习

读取一个npz文件，因为无法上传，直接写出内容

1、['工号' '姓名' '部门' '岗位' '薪资' '工龄' '满意度' '状态']
2、[['lol-1' '孙悟空' '战士' '上单' '50000' '10' '3' '离职']
 ['lol-10' '光辉' 'AP' '中单' '10000' '3' '2' '在职']
 ['lol-11' '石头人' '坦克' '辅助' '5000' '3' '1' '在职']
 ['lol-12' '萝莉' 'AD' '射手' '50000' '3' '3' '离职']
 ['lol-13' '提莫' 'AP' '辅助' '2500' '3' '2' '在职']
 ['lol-14' '狗头' '战士' '上单' '11000' '3' '1' '在职']
 ['lol-15' '轮子妈' 'AD' '射手' '12500' '3' '1' '在职']
 ['lol-16' '冰鸟' 'AP' '辅助' '20000' '2' '2' '在职']
 ['lol-17' '牛头' '坦克' '辅助' '8000' '2' '1' '在职']
 ['lol-18' '剑豪' '刺客' '中单' '2500' '2' '2' '在职']
 ['lol-19' '男刀' '刺客' '中单' '20000' '2' '1' '在职']
 ['lol-2' '剑圣' '刺客' '打野' '25000' '6' '2' '在职']
 ['lol-20' '阿木木' 'AP' '打野' '13500' '1' '3' '离职']
 ['lol-3' '寒冰' 'AD' '射手' '15000' '5' '2' '在职']
 ['lol-3' '寒冰' 'AD' '射手' '15000' '5' '2' '在职']
 ['lol-4' '影子' '刺客' '中单' '30000' '5' '3' '离职']
 ['lol-5' '蒙多' '坦克' '上单' '8000' '5' '1' '在职']
 ['lol-6' '小炮' 'AD' '射手' '20000' '5' '2' '在职']
 ['lol-7' '盖伦' '战士' '上单' '12000' '5' '1' '在职']
 ['lol-7' '盖伦' '战士' '上单' '12000' '5' '1' '在职']
 ['lol-8' '蛇女' 'AP' '中单' '13000' '4' '3' '离职']
 ['lol-9' '蛮王' '战士' '上单' '8000' '4' '3' '离职']]

要求：

各部门有多少名员工？
员工总体流失率是多少？
员工平均薪资是多少？
员工平均工作年限是多少？
公司任职时间最久的三名员工是谁？
员工整体满意度如何？

解答
方法不唯一，我自己写的可能复杂了。

from collections import Counter

import numpy as np

data = np.load('yingxionglianmeng.npz', allow_pickle=True)
# print(list(data))
arr0 = np.array(data['arr_0'])
arr1 = np.array(data['arr_1'],dtype='str')
arr1 = np.unique(arr1, axis=0)
print(arr1)


# 1、各部门有多少名员工？
department_arr = arr1[::,2]
print(Counter(department_arr))  # Counter({'AP': 5, '战士': 4, 'AD': 4, '刺客': 4, '坦克': 3})


# 2、员工总体流失率是多少？
state = arr1[:, 7]
lz_sum = Counter(state)['离职']
lz_rate = lz_sum / state.size
# 转换为百分号方法一：
print("%.2f%%" % (lz_rate * 100))  # 30.00%
# 方法二：
print(str(lz_rate * 100)[:2] + '%')  # 30%


# 3、员工平均薪资是多少？
salary_sum = arr1[:,4].astype("int")
a = salary_sum.cumsum()[-1]
avg_salary = a / arr1[:, 4].size
print(avg_salary)  # 16800.0


# 4、员工平均工作年限是多少？
# 方法一：
a = arr1[:, 5].astype("int")
print(a.mean())  # 3.8

# 方法二：
year_arr = np.array([int(i) for i in arr1[:, 5]])
print(year_arr.mean())  # 3.8


# 5、公司任职时间最久的三名员工是谁？
len_year = arr1[:, 5].astype("int")
sy = len_year.argsort()[-3:]
hero_name = arr1[:, 1][sy][::-1]
print("在公司任职时间最久的三名员工是：", hero_name)


# 6、员工整体满意度如何？
satisfaction = arr1[:, -2].astype("int")
avg_satisfaction = satisfaction.cumsum()[-1] / satisfaction.size
print("员工整体满意度为：",avg_satisfaction)

Allbuypy

关注

10
点赞
踩
18

收藏

觉得还不错? 一键收藏
9
评论
python-numpy--矩阵与数组的操作

一、numpy矩阵安装numpy：pip install numpynumpy简介numpy是计算模块，主要有两种类型：数组、矩阵特点：运算快1、创建矩阵mat1 = np.mat("1 2 3;2 3 4;1 2 3")mat2 = np.mat("1 7; 2 2; 8 2")mat3 = np.mat("1 2 3;2 3 4;1 2 3")mat4 = np.mat("1 0 0;0 4 0;0 0 6")print(mat1)[[1 2 3] [2 3 4] [1 2 3
复制链接

扫一扫