Numpy矩阵运算与矩阵属性、数组通用函数、数组的广播机制、数组的存储与读取

1.矩阵运算与矩阵属性：（mat、matmul、dot、multiply、.T转置矩阵、.H共轭转置矩阵、.I逆矩阵、.A视图）

import  numpy as np

# 创建一个矩阵
m1 = np.mat([[1,2,3],[4,5,6],[0,1,2]])
# print("m1:\n",m1)
# print("m1的类型：\n",type(m1))
"""
m1:
 [[1 2 3]
 [4 5 6]
 [0 1 2]]
m1的类型：
 <class 'numpy.matrix'>
"""


# 矩阵运算
# 矩阵与数的相乘 ---对应元素与数进行相乘
m2 = m1 * 2
# print("m2:\n",m2)
"""
m2:
 [[ 2  4  6]
 [ 8 10 12]
 [ 0  2  4]]
"""


# 矩阵与数的相除---对应元素与数进行相除
m2 = m1 / 2
# print("m2:\n",m2)
"""
m2:
 [[0.5 1.  1.5]
 [2.  2.5 3. ]
 [0.  0.5 1. ]]
"""


# 矩阵的加减 ---对应元素的相加减
m2 = m1 + 1
# print("m2:\n",m2)
"""
m2:
 [[2 3 4]
 [5 6 7]
 [1 2 3]]
"""


m2 = m1 - 1
# print("m2:\n",m2)
"""
m2:
 [[ 0  1  2]
 [ 3  4  5]
 [-1  0  1]]
"""


# 矩阵与矩阵的相加减
# m1 + m2
# 矩阵相加 也是对应元素的相加
m3 = m1 + m2
# print("m3:\n",m3)
"""
m3:
 [[ 1  3  5]
 [ 7  9 11]
 [-1  1  3]]
"""


# 矩阵相减 也是对应元素的相减
m3 = m1 - m2
# print("m3:\n",m3)
"""
m3:
 [[1 1 1]
 [1 1 1]
 [1 1 1]]
"""

#-----------------------------------------分割线----------------------------------------------
# 不同形的矩阵 运算 需要满足广播机制
m2 = np.mat([[0,1,2],[1,2,3]])
# m3 = m1 + m2 # 不能进行相加
# print(m3)
"""
ValueError: operands could not be broadcast together with shapes (3,3) (2,3) 
"""


# 同形矩阵能进行与数的运算，矩阵与矩阵的相加减
# 不同形的矩阵 相加减需要满足 广播机制


# 矩阵与矩阵的相乘 ----》m*n矩阵   n*l矩阵
# 必须满足矩阵相乘规则：
# m,n矩阵 *  n,l矩阵 =m,l矩阵
# 创建一个矩阵
m1 = np.mat(np.arange(1,7).reshape((2,3)))
m2 = np.mat(np.arange(6,0,-1).reshape((3,2)))
# m2 = np.mat(np.arange(6,0,-1).reshape((2,3)))
# print("m1:\n",m1)
# print("m2:\n",m2)
"""
m1:
 [[1 2 3]
 [4 5 6]]
m2:
 [[6 5]
 [4 3]
 [2 1]]
"""


# 进行相乘
# new_m = m1 * m2


# 借助函数进行相乘
# new_m = np.matmul(m1,m2) # 推荐这种
new_m = np.dot(m1,m2)  # 推荐
# print("new_m:\n",new_m)
"""
[[20 14]
 [56 41]]
"""


# 对应元素相乘
# new_m = np.multiply(m1,m2)
# print("new_m:\n",new_m)



# print("m1 的转置：\n",m1.T)
"""
m1 的转置：
 [[1 4]
 [2 5]
 [3 6]]
"""

# print("m1 的共轭转置：\n",m1.H)
"""
m1 的共轭转置：
 [[1 4]
 [2 5]
 [3 6]]
"""

# print("m1 的逆矩阵：\n",m1.I)
"""
[[-0.94444444  0.44444444]
 [-0.11111111  0.11111111]
 [ 0.72222222 -0.22222222]]
"""

# print("m1 * m1 的逆矩阵\n",m1*m1.I)
"""
[[ 1.00000000e+00  3.05311332e-16]
 [-4.44089210e-16  1.00000000e+00]]
"""

# print("m1 的视图：\n",m1.A)
"""
[[1 2 3]
 [4 5 6]]
"""

# print("m1 的视图的类型：\n",type(m1.A))
"""
<class 'numpy.ndarray'>
"""

2.数组的通用函数：（数组的加+减- 乘* 除/ 冥运算**，比较运算、逻辑运算）

import  numpy as np

# 数组四则运算 + - *  /  **
# 组间的四则运算表示对每个数组中的元素分别进行四则运算，所以形状必须相同。
arr1 = np.array([[1,2],[3,4]])
arr2 = np.array([[1,1],[1,2]])
# print("arr1:\n",arr1)
# print("arr2:\n",arr2)
"""
arr1:
 [[1 2]
 [3 4]]
arr2:
 [[1 1]
 [1 2]]
"""


# 数组相加--对应元素的相加
arr = arr1 + arr2
# print("arr:\n",arr)
"""
arr:
 [[2 3]
 [4 6]]
"""


# 数组相减--对应元素的相减
arr = arr1 - arr2
# print("arr:\n",arr)
"""
arr:
 [[0 1]
 [2 2]]

"""


# 数组相乘--对应元素的相乘
arr = arr1 * arr2
# print("arr:\n",arr)
"""
arr:
 [[1 2]
 [3 8]]

"""


# 数组相除--对应元素的相除
arr = arr1 / arr2
# print("arr:\n",arr)
"""
arr:
 [[1. 2.]
 [3. 2.]]
"""


# 数组求幂--对应元素的对应次幂
arr = arr1 ** arr2
# print("arr:\n",arr)
"""
arr:
 [[ 1  2]
 [ 3 16]]
"""

#-----------------------------------------分割线----------------------------------------------
# 比较运算 == 返回bool数组，是对应位置元素进行对比的结果
# print(" == :\n",arr1 == arr2)
# print(" != :\n",arr1 != arr2)
# print(" >= :\n",arr1 >= arr2)
# print(" <= :\n",arr1 <= arr2)
# print(" > :\n",arr1 > arr2)
# print(" < :\n",arr1 < arr2)
"""
 == :
 [[ True False]
 [False False]]
 
 != :
 [[False  True]
 [ True  True]]
 
 >= :
 [[ True  True]
 [ True  True]]
 
 <= :
 [[ True False]
 [False False]]
 
 > :
 [[False  True]
 [ True  True]]
 
 < :
 [[False False]
 [False False]]
"""


# 逻辑运算
# np.any()  相当于or,只要有一个为True，则为True，否则为False
# print("any:\n",np.any(arr1>=arr2))
"""
any:
 True
"""

# print(np.any(arr1 < arr2))
"""
False
"""

# np.all()  相当于and
# print("all:\n",np.all(arr1 >= arr2))
"""
all:
 True
"""

3.数组的广播机制：

广播机制：
广播（broadcasting）是指不同形状的数组之间执行算术运算的方式。需要遵循4个原则：

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

Ø 输出数组的shape是输入数组shape的各个轴上的最大值。

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

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

import  numpy as np

# 创建两个不同形状的数组
arr1 =  np.arange(9).reshape((3,3))
# print("arr1:\n",arr1)
"""
arr1:
 [[0 1 2]
 [3 4 5]
 [6 7 8]]
"""

#------------------分割线-------------------------


arr2 = np.arange(1,2).reshape((1,1))
# print("arr2:\n",arr2)
"""
arr2:
 [[1]]
"""
# 数组的算术运算
arr = arr1 + arr2
# print("arr:\n",arr)
"""
arr:
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
"""

#------------------分割线-------------------------
arr2 = np.arange(9).reshape((3,3))
# print("arr2:\n",arr2)
"""
[[0 1 2]
 [3 4 5]
 [6 7 8]]
"""
# 数组的算术运算
arr = arr1 + arr2
# print("arr:\n",arr)
"""
arr:
 [[ 0  2  4]
 [ 6  8 10]
 [12 14 16]]
"""

#------------------分割线-------------------------
arr2= np.array([[1,2,3]]) # (1,3)
# print("arr2:\n",arr2)
"""
arr2:
 [[1 2 3]]
"""
# 数组的算术运算
arr = arr1 + arr2
# print("arr:\n",arr)
"""
arr:
 [[ 1  3  5]
 [ 4  6  8]
 [ 7  9 11]]
"""
#------------------分割线-------------------------
arr2= np.array([1,2,3]) # (1,3)
# print("arr2:\n",arr2)
"""
arr2:
 [1 2 3]
"""
# 数组的算术运算
arr = arr1 + arr2
print("arr:\n",arr)
"""
arr:
 [[ 1  3  5]
 [ 4  6  8]
 [ 7  9 11]]
"""


# arr1 shape(2,3,4,5)与arr2 shape(3,1,5)可以相加。
# arr1 shape(2,3,4) 与 arr2 shape(1,1,4)也可以相加。

4.数组的存储与读取：（save、savez、load、savetxt、loadtxt、genfromtxt（推荐使用））

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

np.save ("…/tmp/save_arr ", arr)

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

np.load("…/tmp/ save_arr.npy")

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

np.savez(’…/tmp/savez_arr’,arr1,arr2)

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

np.savetxt("…/tmp/arr.txt", arr, fmt="%d", delimiter=",")
## fmt="%d"表示保存为整数，delimiter=","表示用‘ , ’ 隔开

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

np.loadtxt("…/tmp/arr.txt",delimiter=",")

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

np.genfromtxt("…/tmp/arr.txt", delimiter = “,”)

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

import  numpy as np

# 二进制形式进行保存与读取

# 创建一个数组
arr1 = np.arange(16).reshape((4,4))
arr2 = np.arange(9).reshape((3,3))

# 保存单个数组
#  参数1 要保存的文件路径+ 名称（后缀名可以省略，默认为.npy结尾）
# 参数2  要保存的数组
# np.save("./arr1",arr1)


#------------------分割线-------------------------


# 将保存的arr加载出来
# arr = np.load("./arr.npy")
# print(arr)

#------------------分割线-------------------------

# 保存多个数组
# 参数1  要保存的文件路径+ 名称（后缀名可以省略，默认为.npz结尾）
# 存储的时候可以指定存储的key=value值
# np.savez("./arr",arr1= arr1,arr2= arr2)

#------------------分割线-------------------------

# 加载.npz数据
# data = np.load("./arr.npz")
# print(data)

# for tmp in data:
    # print(tmp)

# print(data['arr1'])
# print(data['arr2'])
# 如果存储的时候不指定key值，默认会key会存储为arr_num 形式
# print(data['arr_0'])
# print(data['arr_1'])
#------------------分割线-------------------------


# 文本形式的存储

# np.savetxt("./arr.txt",arr1,fmt='%d',delimiter=",")

#------------------分割线-------------------------

# 加载  读取的时候必须指定分隔符，而且可以通过dtype进行类型的更改
# data = np.loadtxt("./arr.txt",delimiter=",",dtype=np.int32)
# print(data)

#------------------分割线-------------------------

# 可以解决数据缺失问题 --------推荐使用
# data = np.genfromtxt("./arr.txt",delimiter=",",dtype=np.int32)
# print(data)