NumPy学习10

今天学习了3节：

18, NumPy副本和视图

19, NumPy字节交换

20, NumPy Matrix矩阵库

numpy_test10.py :

import numpy as np

'''
18, NumPy副本和视图

对 NumPy 数组执行些函数操作时，其中一部分函数会返回数组的副本，而另一部分函数则返回数组的视图。

其实从内存角度来说，副本就是对原数组进行深拷贝，新产生的副本与原数组具有不同的存储位置。
而视图可理解为对数组的引用，它和原数组有着相同的内存位置。
'''
print("----18, NumPy副本和视图----")
'''
(1) 赋值操作
赋值操作是数组引用的一种方法，可以称为 视图 。比如，将 a 数组赋值给变量 b，被赋值后的变量 b 与 a 组具有相同的内存 id。
因此，无论操作 a、b 中哪个数组，另一个数组也会受到影响。
'''
print("----(1) 赋值操作----")
arr1 = np.array([[1, 2, 3, 4], [5, 2, 3, 1], [1, 5, 3, 13]])
print('arr1 : ', arr1)
print("arr1数组的id:", id(arr1))
arr2 = arr1
print("arr2数组的id:", id(arr2))
# 修改 arr2 数组的形状大小
arr2.shape = (4, 3)
print("arr2 数组形状的更改也会反映到 arr1 数组上:")
print('arr1 : ', arr1)
'''
arr1 :  [[ 1  2  3  4]
         [ 5  2  3  1]
         [ 1  5  3 13]]
arr1数组的id: 1787774881088
arr2数组的id: 1787774881088
arr2 数组形状的更改也会反映到 arr1 数组上:
arr1 :  [[ 1  2  3]
         [ 4  5  2]
         [ 3  1  1]
         [ 5  3 13]]
'''

'''
(2) ndarray.view()
ndarray.view() 返回一个新生成的数组副本，因此对该数组的操作，不会影响到原数组。
'''
print("----(2) ndarray.view()----")
arr3 = np.array([[1, 2, 3, 4], [5, 2, 3, 1], [1, 5, 3, 13]])
print('arr3 : ', arr3)
print("arr3 数组的id:", id(arr3))
arr4 = arr3.view()
print("arr4 数组的id:", id(arr4))
print('arr4 : ', arr4)
# 修改 arr4 数组的形状大小
arr4.shape = (4, 3)
print("修改 arr4 数组的形状大小后：")
print("arr3 : ", arr3)
print("arr4 : ", arr4)
'''
arr3 :  [[ 1  2  3  4]
         [ 5  2  3  1]
         [ 1  5  3 13]]
arr3 数组的id: 2462990769912
arr4 数组的id: 2462990948464
arr4 :  [[ 1  2  3  4]
         [ 5  2  3  1]
         [ 1  5  3 13]]
修改 arr4 数组的形状大小后：
arr3 :  [[ 1  2  3  4]
         [ 5  2  3  1]
         [ 1  5  3 13]]
arr4 :  [[ 1  2  3]
         [ 4  5  2]
         [ 3  1  1]
         [ 5  3 13]]
'''

'''
(3) 切片创建视图
使用切片可以创建视图数组，若要修改视图的就会影响到原数组。
'''
print("----(3) 切片创建视图----")
arr5 = np.array([1, 2, 3, 4, 5, 2, 3, 5, 3, 13])
print('arr5 : ', arr5)
print("arr5 数组的id:", id(arr5))
# 创建切片修改原数组arr
arr5_a = arr5[5:]
print('arr5_a : ', arr5_a)
arr5_b = arr5[6:]
print('arr5_b : ', arr5_b)
arr5_a[1] = 23
arr5_b[2] = 45
print("切片修改原数组arr5后：")
print('arr5 : ', arr5)
print("arr5 数组的id:", id(arr5))
'''
arr5 :  [ 1  2  3  4  5  2  3  5  3 13]
arr5 数组的id: 1911254767552
arr5_a :  [ 2  3  5  3 13]
arr5_b :  [ 3  5  3 13]
切片修改原数组arr5后：
arr5 :  [ 1  2  3  4  5  2 23  5 45 13]
arr5 数组的id: 1911254767552
'''

'''
(4) ndarray.copy()
该方法返回原数组的副本，对副本的修改不会影响到原数组。
'''
print("----(4) ndarray.copy()----")
arr6 = np.array([[1, 2, 3, 4], [5, 2, 3, 1], [1, 5, 3, 13]])
print('arr6 : ', arr6)
print("arr6 数组的id:", id(arr6))
arr7 = arr6.copy()
print('arr7 : ', arr7)
print("arr7 数组的id:", id(arr7))
# 修改 arr7 数组的形状大小
arr7.shape = (4, 3)
print("修改 arr7 数组的形状大小后：")
print('arr7 : ', arr7)
print("arr7 数组的id:", id(arr7))
'''
arr6 :  [[ 1  2  3  4]
         [ 5  2  3  1]
         [ 1  5  3 13]]
arr6 数组的id: 2399353014648
arr7 :  [[ 1  2  3  4]
         [ 5  2  3  1]
         [ 1  5  3 13]]
arr7 数组的id: 2399353014736
修改 arr7 数组的形状大小后：
arr7 :  [[ 1  2  3]
         [ 4  5  2]
         [ 3  1  1]
         [ 5  3 13]]
arr7 数组的id: 2399353014736
'''

'''
19, NumPy字节交换
数据以字节的形式存储在计算机内存中，而存储规则可分为两类，即小端字节序与大端字节序。

小端字节序（little-endian），表示低位字节排放在内存的低地址端，
    高位字节排放在高地址段，它与大端字节序（big-endian）恰好相反。

对于二进制数 0x12345678，假设从地址 0x4000 开始存放，在大端和小端模式下，它们的字节排列顺序，如下所示：
            内存地址增大方向
<----------------------------------------
     0x4003   0x4002  0x4001  0x4000
       ↆ       ↆ       ↆ      ↆ
|0x12|...|0x34|...|0x56|...|0x78|...《=== 小端
|0x78|...|0x56|...|0x34|...|0x12|...《=== 大端
<----------------------------------------
图1：字节存储模式

小端存储后：0x78563412  大端存储后：0x12345678。
'''
print("----19, NumPy字节交换----")
'''
(1) ndarray.byteswap()
该函数将数组中每个元素的字节顺序进行大小端调换。
'''
print("----(1) ndarray.byteswap()----")
arr8 = np.array([1, 346, 825], dtype=np.int16)
print('arr8 : ', arr8)
# 以16进制形式表示内存中的数据
print('map(hex, arr8) : ', map(hex, arr8))
# byteswap()函数通过传递True参数在适当的位置进行转换
arr9 = arr8.byteswap(True)
print('arr8.byteswap(True) 位置进行转换后数组: ')
print('arr9 : ', arr9)
# 以16进制形式表示内存中的数据
print('map(hex, arr8) : ', map(hex, arr8))
'''
arr8 :  [  1 346 825]
map(hex, arr8) :  <map object at 0x000001737739AAC8>
arr8.byteswap(True) 位置进行转换后数组:
arr9 :  [  256 23041 14595]
map(hex, arr8) :  <map object at 0x0000017376E96780>
'''

'''
20, NumPy Matrix矩阵库
NumPy 提供了一个 矩阵库模块numpy.matlib，该模块中的函数返回的是一个 matrix 对象，而非 ndarray 对象。
矩阵由 m 行 n 列（m*n）元素排列而成，矩阵中的元素可以是数字、符号或数学公式等。
'''
print("----20, NumPy Matrix矩阵库----")
'''
(1) numpy.matlib.empty()
matlib.empty() 返回一个空矩阵，所以它的创建速度非常快。
numpy.matlib.empty(shape, dtype, order)

该函数的参数说明如下：
shape：以元组的形式指定矩阵的形状。
dtype：表示矩阵的数据类型。
order：有两种选择，C（行序优先） 或者 F（列序优先）。
'''
import numpy.matlib
print("----(1) np.matlib.empty()----")
# 矩阵中会填充无意义的随机值
matrix1 = np.matlib.empty((2, 2))
print('matrix1 : ', matrix1)
'''
matrix1 :  [[9.90263869e+067 8.01304531e+262]
            [2.60799828e-310 1.13738974e-311]]
'''

'''
(2) numpy.matlib.zeros()
numpy.matlib.zeros() 创建一个以 0 填充的矩阵.
'''
print("----(2) numpy.matlib.zeros()----")
# 创建一个以 0 填充的矩阵
matrix2 = np.matlib.zeros((2, 2))
print('matrix2 : ', matrix2)
'''
matrix2 :  [[0. 0.]
            [0. 0.]]
'''

'''
(3) numpy.matlib.ones()
numpy.matlib.ones() 创建一个以 1 填充的矩阵。
'''
print("----(3) numpy.matlib.ones()----")
# 创建一个以 1 填充的矩阵
matrix3 = np.matlib.ones((2, 2))
print('matrix3 : ', matrix3)
'''
matrix3 :  [[1. 1.]
            [1. 1.]]
'''

'''
(4) numpy.matlib.eye()
numpy.matlib.eye() 返回一个对角线元素为 1，而其他元素为 0 的矩阵 。
----行列数不一定一致。

numpy.matlib.eye(n, M, k, dtype)：
n：返回矩阵的行数；
M：返回矩阵的列数，默认为 n；
k：对角线的索引；
dtype：矩阵中元素数据类型。
'''
print("----(4) numpy.matlib.eye()----")
# 创建一个对角线元素为 1，而其他元素为 0 的矩阵
matrix4 = np.matlib.eye(n=3, M=4, k=0, dtype=int)
print('matrix4 : ', matrix4)
'''
matrix4 :  [ [1 0 0 0]
             [0 1 0 0]
             [0 0 1 0]]
'''

'''
(5) numpy.matlib.identity()
该函数返回一个给定大小的单位矩阵，矩阵的对角线元素为 1，而其他元素均为 0。
----行列数一致。
'''
print("----(5) numpy.matlib.identity()----")
# 创建一个给定大小的单位矩阵，矩阵的对角线元素为 1，而其他元素均为 0 的矩阵
matrix5 = np.matlib.identity(3, dtype=int)
print('matrix5 : ', matrix5)
'''
matrix5 :  [ [1 0 0]
             [0 1 0]
             [0 0 1]]
'''

'''
(6) numpy.matlib.rand()
numpy.matlib.rand() 创建一个以随机数填充，并给定维度的矩阵。
'''
print("----(6) numpy.matlib.rand()----")
# 创建一个以随机数填充，并给定维度的矩阵
matrix6 = np.matlib.rand(3, 3)
print('matrix6 : ', matrix6)
'''
matrix6 :  [ [0.47852887 0.45872498 0.74952163]
             [0.52896064 0.87761579 0.23843873]
             [0.8692609  0.74930949 0.36049231]]
'''

'''
(7) matrix 与 ndarray 之间的转换
这里需要注意，因为 matrix 只能表示二维数据，而 ndarray 也可以是二维数组，所以两者可以互相转换。
'''
print("----(7) matrix 与 ndarray 之间的转换----")
# 创建矩阵方式1
matrix7 = np.matrix('1,2;3,4')
print('matrix7 : ', matrix7)
# 创建矩阵方式2
matrix8 = np.matrix([[5, 6], [7, 8]])
print('matrix8 : ', matrix8)
# 创建矩阵方式3
arr10 = np.array([[5, 6], [7, 8]])
print('arr10 : ', arr10)
matrix9 = np.matrix(arr10)
print('matrix9 : ', matrix9)
print('type(matrix9) : ', type(matrix9))

# matrix 转换为 ndarray
print("----matrix 转换为 ndarray----")
arr11 = np.asarray(matrix9)
print('arr11 : ', arr11)
print('type(arr11) : ', type(arr11))
#  ndarray 转换为 matrix
print("----ndarray 转换为 matrix----")
matrix10 = np.asmatrix(arr11)
print('matrix10 : ', matrix10)
print('type(matrix10) : ', type(matrix10))
'''
matrix7 :  [[1 2]
            [3 4]]
matrix8 :  [[5 6]
            [7 8]]
arr10 :  [[5 6]
          [7 8]]
matrix9 :  [[5 6]
            [7 8]]
type(matrix9) :  <class 'numpy.matrix'>
----matrix 转换为 ndarray----
arr11 :  [[5 6]
          [7 8]]
type(arr11) :  <class 'numpy.ndarray'>
----ndarray 转换为 matrix----
matrix10 :  [[5 6]
             [7 8]]
type(matrix10) :  <class 'numpy.matrix'>
'''