numpy（二）：矩阵创建+矩阵运算+矩阵属性+矩阵文件读写+矩阵排序+矩阵的重复+矩阵去重+聚合函数

一、什么是矩阵

☞☞☞☞点我查看矩阵的详细介绍☜☜☜☜

二、矩阵的创建 1.mat()函数—matrix函数的缩写

import numpy as np
# 格式1：字符串参数
A = np.mat('1 1 1;2 2 2;3 3 3')
print(A)
# 格式2：类似array
B = np.mat([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
print(B)

结果：

2.matrix()函数

C = np.matrix('1 1 1;2 2 2;3 3 3')
# print(C)
# 格式2：类似array
D = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# print(D)

结果：

3.bmat()函数------通过分块矩阵创建big矩阵

#格式一：传入字符串类型的矩阵
big_map1 = np.bmat('A B;C D')
#格式二：传入参数型
big_map2 = np.bmat([[A, B], [C, D]])
print(big_map1)
print(big_map2)

结果：

三、矩阵的运算（加/减/乘/矩阵的对应相乘）

1.矩阵与数的相乘

A = np.mat([[1, 1], [1, 1]])
print(A * 3)

'''
结果：
[[3 3]
 [3 3]]
'''

2.矩阵加减法

A = np.mat([[1, 1], [1, 1]])
B = np.mat([[1, 2], [3, 4]])
print(A - B)
'''
结果：
[[ 0 -1]
 [-2 -3]]

'''

3.矩阵相乘（矩阵A的行=矩阵B的列）

A1= np.mat([[1, 1], [1, 1]])
B1 = np.mat([[1, 2], [3, 4]])
print(A1*B1)
'''
结果：
[[4 6]
 [4 6]]
'''

.4.矩阵对应元素相乘multiply()

A1= np.mat([[1, 1], [1, 1]])
B1 = np.mat([[1, 2], [3, 4]])
print(np.multiply(A1, B1))
'''
结果：
[[1 2]
 [3 4]]
'''

四、矩阵的常用属性（转置/共轭/逆/视图）

例如有一个数组记为arr

写法作用arr.T矩阵的转置arr.H共轭转置矩阵arr.I逆矩阵arr.A返回自身数据的二维数组的一个视图

举例：

C = np.mat([[1, 2], [3, 4]])

# --------------------1.转置T
print(C.T)
'''
[[1 3]
 [2 4]]
 '''

# ---------------------2.共轭转置矩阵H
print(C.H)
'''
[[1 3]
 [2 4]]
 '''

# ---------------------3.逆矩阵I
print(C.I)
'''
[[-2.   1. ]
 [ 1.5 -0.5]]
'''

# ----------------------4.返回自身数据的二维数组的一个视图A
print(C.A, type(C.A))
'''
[[1 2]
 [3 4]]  
'''

五、numpy的文件读写

注意：存储可以省略拓展名，读取不可以省略拓展名

1.save（）和savetxt（）

1.使用save函数保存的是二进制文件，文件的拓展名为.npy

格式：np.save('文件名', numpy数据)

2.savetxt函数保存的是文本文件

格式：np.savetxt('文件名', numpy数据)

举例：

x = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]])
np.save('x', x)
np.savetxt('x_txt', x)

注意：二进制文件保存比文本文件处理速度快，效率高

2.savez()，将多个数组保存成一个压缩包.npz格式，压缩包里还是各自保存

np.savetz('文件名', numpy数据1,numpy数据2...)

例如

a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.arange(0, 1, 0.1)
np.savez('a_b', a, b)

——————————————————————————————————

3.load（）

result = np.load('x.npy')
print(result, type(result))

4.loadtxt（）读取文本文件（格式：txt,csv)

result = np.loadtxt('x_txt.txt')
print(result)

5.genfromtxt保存结构化数据

df = np.dtype([('name', np.str_, 128), ('nums', np.int32), ('local', np.str_, 64)])
job = np.genfromtxt('job.txt', dtype=df, delimiter=',')
print(job)
print(job['name'])

六、numpy的排序 1.直接排序sort（）

①sort函数是常用的排序方法,sort函数可以指定一个axis参数，使的sort函数沿着指定轴进行排序:

• axis=1沿着横轴，
• axis=0沿着纵轴
• 默认按shape的最后一位索引排序

例如（3,2），按照最后一位的索引数排序。为1.所以按横轴排序

②sort函数分为：

• numpy.sort(arr,axis=num)，有返回值类似sorted
• arr.sort(axis=num)，无返回值，原数据变化

举例：

arr = np.array([[4, 3, 2], [2, 1, 4]])
print('原始数据：\n', arr)
print('---------------横轴从小到大--------')
print(np.sort(arr, axis=1))
print('---------------纵轴从小到大--------')
print(np.sort(arr, axis=0))
print('--------------- 原数据未变化--------')
print(arr)  
print('----------使原数据变化,也可以写axis的参数，规则同上--------')
arr.sort() 
print(arr)

2.间接排序（不改变原始数据）

（1）argsort()函数：将排序后的数组的索引值返回

arr = np.array([7, 3, -3, 6, 4])
new_arr = arr.argsort()
print('argsort()排序前：\n', arr)
print('argsort()排序后：\n', new_arr)

（2）lexsort()按照最后一个传入数据进行排序，返回的结果依然是索引，实际传入的前边没什么用

arr1 = np.array([7, 423, -13, 346, 412])
arr2 = np.array([71, -3, -3, 236, 43])
print(np.lexsort((arr2, arr2)))

七、numpy的重复和去重 1.tile(数组，重复次数)--------对数组整体进行重复操作

arr = np.array([1, 2, 3, 4])
print(np.tile(arr, 3))
'''
结果：[1 2 3 4 1 2 3 4 1 2 3 4]
'''

arr1 = np.array([[1, 2, 3], [4, 5, 6]])
print(np.tile(arr1, 3))
'''
 结果：        [[1 2 3 1 2 3 1 2 3]
              [4 5 6 4 5 6 4 5 6]]
'''

2.repeat(数组，重复次数)----对数组中每个元素进行重复操作

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

print(np.repeat(arr1,2, axis=0))#按行
print(np.repeat(arr1,2, axis=1))#按列
'''
    按行 [[1 2]     按列    [[1 1 2 2]
        [1 2]              [3 3 4 4]]
        [3 4]
        [3 4]]

'''

练习： ①生成3x3的十以内的整数数组 ②将数组按行进行重复，重复次数为2

a = np.random.randint(0, 9, size=(3, 3))
print(np.repeat(a, 2, axis=0))

3.unique()去重

结果：[1,2,3,4]

八、聚合函数

# 读取iris数据集中的长度数据（csv），并对其进行排序去重，并
# 求和，求累计和，均值，标准查，方差，最小值，最大值

import numpy as np

# 1.读取文件
iris = np.loadtxt('iris_sepal_length.csv')
# print('花萼的长度表：', iris)

# 2.排序
iris.sort()
# print('排序后的结果：', iris)

# 3.去重
unique_iris = np.unique(iris)
print('去重后的结果：', unique_iris)

# 4.统计函数
print('求和：',np.sum(iris))
print('累计和：',np.cumsum(iris))
print('均值：',np.mean(iris))
print('标准差：',np.std(iris))
print('方差：',np.var(iris))
print('最小值：',np.min(iris))
print('最大值：',np.max(iris))

结果：

去重后的结果： [ 4.3  4.4  4.5  4.6  4.7  4.8  4.9  5.   5.1  5.2  5.3  5.4  5.5  5.6  5.7
  5.8  5.9  6.   6.1  6.2  6.3  6.4  6.5  6.6  6.7  6.8  6.9  7.   7.1  7.2
  7.3  7.4  7.6  7.7  7.9]
求和： 876.5
累计和： [   4.3    8.7   13.1   17.5   22.    26.6   31.2   35.8   40.4   45.1
   49.8   54.6   59.4   64.2   69.    73.8   78.7   83.6   88.5   93.4
   98.3  103.2  108.2  113.2  118.2  123.2  128.2  133.2  138.2  143.2
  148.2  153.2  158.3  163.4  168.5  173.6  178.7  183.8  188.9  194.
  199.1  204.3  209.5  214.7  219.9  225.2  230.6  236.   241.4  246.8
  252.2  257.6  263.1  268.6  274.1  279.6  285.1  290.6  296.1  301.7
  307.3  312.9  318.5  324.1  329.7  335.4  341.1  346.8  352.5  358.2
  363.9  369.6  375.3  381.1  386.9  392.7  398.5  404.3  410.1  415.9
  421.8  427.7  433.6  439.6  445.6  451.6  457.6  463.6  469.6  475.7
  481.8  487.9  494.   500.1  506.2  512.4  518.6  524.8  531.   537.3
  543.6  549.9  556.2  562.5  568.8  575.1  581.4  587.7  594.1  600.5
  606.9  613.3  619.7  626.1  632.5  639.   645.5  652.   658.5  665.
  671.6  678.2  684.9  691.6  698.3  705.   711.7  718.4  725.1  731.8
  738.6  745.4  752.2  759.1  766.   772.9  779.8  786.8  793.9  801.1
  808.3  815.5  822.8  830.2  837.8  845.5  853.2  860.9  868.6  876.5]
均值： 5.84333333333
标准差： 0.825301291785
方差： 0.681122222222
最小值： 4.3
最大值： 7.9