Python numpy中矩陣的用法總結

時間 2019-11-19

原文原文鏈接

　　關於Python Numpy庫基礎知識請參考博文：http://www.javashuo.com/article/p-trittluo-c.htmlhtml

Python矩陣的基本用法

　　mat（）函數將目標數據的類型轉化成矩陣（matrix）python

1，mat()函數和array()函數的區別

　　Numpy函數庫中存在兩種不一樣的數據類型（矩陣matrix和數組array），均可以用於處理行列表示的數字元素，雖然他們看起來很類似，可是在這兩個數據類型上執行相同的數學運算可能獲得不一樣的結果，其中Numpy函數庫中的matrix與MATLAB中matrices等價。數組

　　直接看一個例子：app

import numpy as np

a = np.mat('1 3;5 7')
b = np.mat([[1,2],[3,4]])
print(a)
print(b)
print(type(a))
print(type(b))
c = np.array([[1,3],[4,5]])
print(c)
print(type(c))

　　結果：dom

[[1 3]
 [5 7]]
[[1 2]
 [3 4]]
<class 'numpy.matrixlib.defmatrix.matrix'>
<class 'numpy.matrixlib.defmatrix.matrix'>
[[1 3]
 [4 5]]
<class 'numpy.ndarray'>

　　首先，mat() 函數與array()函數生成矩陣所需的數據格式有區別，mat()函數中數據能夠爲字符串以分號（;）分割或者爲列表形式以逗號（，）分割，而array()函數中數據只能爲後者形式。機器學習

　　其次，二者的類型不一樣，用mat函數轉換爲矩陣後才能進行一些線性代數的操做。函數

from numpy import *

# 構建一個4*4的隨機數組
array_1 = random.rand(4,4)
print(array_1)
print(type(array_1))
'''
[[0.12681561 0.26644355 0.03582107 0.71475804]
 [0.01380711 0.85308305 0.37838406 0.83663897]
 [0.20034209 0.5736587  0.56692541 0.64008518]
 [0.97780979 0.129229   0.37688616 0.55341492]]
 
 <class 'numpy.ndarray'>
 '''
# 使用mat函數將數組轉化爲矩陣
matrix_1 = mat(array_1)
print(matrix_1)
print(type(matrix_1))
'''
[[0.32538457 0.60674013 0.68625186 0.58957989]
 [0.26465813 0.93378939 0.12944934 0.95064032]
 [0.65683256 0.01352025 0.11932895 0.9361348 ]
 [0.11667241 0.16077876 0.50904118 0.44128675]]
 
<class 'numpy.matrixlib.defmatrix.matrix'>
'''

2，mat()函數建立常見的矩陣

import numpy as np

# 建立一個3*3的零矩陣，矩陣這裏zeros函數的參數是一個tuple類型（3,3）
data1 = np.mat(np.zeros((3,3)))
print(data1)
'''
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

'''
# 建立一個2*4的1矩陣，默認是浮點型的數據，若是須要時int，可使用dtype=int
data2 = np.mat(np.ones((2,4)))
print(data2)
'''
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]]
'''

# 這裏使用numpy的random模塊
# random.rand(2,2)建立的是一個二維數組，可是須要將其轉化爲matrix
data3 = np.mat(np.random.rand(2,2))
print(data3)
'''
[[0.62002668 0.55292404]
 [0.53018371 0.1548954 ]]
'''

# 生成一個3*3的0-10之間的隨機整數矩陣，若是須要指定下界能夠多加一個參數
data4  = np.mat(np.random.randint(10,size=(3,3)))
print(data4)
'''
[[0 4 1]
 [7 9 9]
 [9 0 4]]
'''

# 產生一個2-8之間的隨機整數矩陣
data5 = np.mat(np.random.randint(2,8,size=(2,5)))
print(data5)
'''
[[4 6 3 3 4]
 [4 3 3 3 6]]
'''

# 產生一個2*2的對角矩陣
data6 = np.mat(np.eye(2,2,dtype=int))
print(data6)
'''
[[1 0]
 [0 1]]
'''
# 生成一個對角線爲1,2,3的對角矩陣
a1 = [1,2,3]
a2 = np.mat(np.diag(a1))
print(a2)
'''
[[1 0 0]
 [0 2 0]
 [0 0 3]]
'''

2.1，zeros

　　zeros函數是生成指定維數的全0數組學習

>>myMat=np.zeros(3)    ###生成一個一維的全0數組
>>print(myMat)
>>array([0.,0.,0.])


>>myMat1=np.zeros((3,2))  ####生成一個3*2的全0數組
>>print(myMat)
>>array([[0.,0.],
        [0.,0.]
        [0.,0.]])

2.2，ones

　　ones函數是用於生成一個全1的數組測試

>>onesMat=np.ones(3)   ###1*3的全1數組
>>print(onesMat)
>>array([1.,1.,1.])



>>onesMat1=np.ones((2,3))   ###2*3的全1數組
>>print(onesMat1)
>>array([[1.,1.,1.],[1.,1.,1.]])

2.3，eye

　　eye函數用戶生成指定行數的單位矩陣ui

>>eyeMat=np.eye(4)  
>>print(eyeMat)
>>array([[1.,0.,0.,0.],
        [0.,1.,0.,0.],
        [0.,0.,1.,0.,],
        [0.,0.,0.,1.]])

2.4，full

　　numpy.full(shape,fill_value=num)用於建立一個自定義形狀的數組,能夠本身指定一個值,用它填滿整個數組。

　　fill_value 用來填充的值，能夠是數字，也能夠是字符串

nd_test = np.full(shape=(2,3,4),fill_value='ai')
print(nd_test)

array([[['ai', 'ai', 'ai', 'ai'],
        ['ai', 'ai', 'ai', 'ai'],
        ['ai', 'ai', 'ai', 'ai']],

       [['ai', 'ai', 'ai', 'ai'],
        ['ai', 'ai', 'ai', 'ai'],
        ['ai', 'ai', 'ai', 'ai']]], dtype='<U2')

2.5 nonzero()

　　nonzero函數是numpy中用於獲得數組array中非零元素的位置（數組索引）函數。它的返回值是一個長度爲a.ndim（數組a的軸數）的元組，元組的每一個元素都是一個整數數組，其值爲非零元素的下標在對應軸上的值。

　　只有a中非零元素纔會有索引值，那些零值元素沒有索引值，經過a[nonzero(a)]獲得全部a中的非零值。

import numpy as np

SS = [0,0,0,0]  
re = np.array(SS)
print(SS)
print(np.nonzero(re))
'''
[0, 0, 0, 0]
(array([], dtype=int64),)
'''

　　a是一維數組（索引1和索引2的位置上元素的值非零）

>>> import numpy as np
>>> a = [0,2,3]
>>> b = np.nonzero(a)
>>> b
(array([1, 2], dtype=int64),)
>>> np.array(b).ndim
2

　　a是多維數組

from numpy import *

b = array([[1,1,1,0,1,1],[1,1,1,0,1,0],[1,1,1,0,1,1]])
print(b)
c = nonzero(b)
print(c)
'''
[[1 1 1 0 1 1]
 [1 1 1 0 1 0]
 [1 1 1 0 1 1]]
(array([0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2], dtype=int64), 
array([0, 1, 2, 4, 5, 0, 1, 2, 4, 0, 1, 2, 4, 5], dtype=int64))
'''

　　解釋一下：矩陣 b中，b[0,0] b[0,1],b[0,2],b[0,4],b[0,5]，b[1,0],b[1,1],b[1,2],b[1,4],b[2,0],b[2,1],b[2,2],b[2,4],b[2,5]元素的值非零。

　　當使用布爾數組直接做爲下標對象護着元組下標對象中有布爾數組時，都至關於用nonzero()將布爾數組轉換成一組整數數組，而後使用整數數組進行下標計算。

　　nonzero(a)返回數組a中值不爲零的元素的下標，它的返回值是一個長度爲a.ndim（數組a的軸數）的元組，元組的每一個元素都是一個整數數組，其值爲非零元素的下標在對應軸上的值。例如對於1維布爾數組b1，nonzero(b1)所獲得的是一個長度爲1的元組，它表示b1[0]和b1[2]的值不爲0（FALSE）。

import numpy as np

b1 = np.array([True,False,True,False])
res1 = np.nonzero(b1)
print(res1)
# (array([0, 2], dtype=int64),)

　　對於二維數組b2，nonzero（b2）所獲得的是一個長度爲2的元組，它的第0個元素是數組a中值不爲0的元素的第0個軸的下標，第一個元素則是第1軸的下標，所以從下面獲得的結果可知b2[0,0] , n2[0,2]和b2[1,0]的值不爲0：

b2 = np.array([[True,False,True],[True,False,False]])
res2 = np.nonzero(b2)
print(res2)
# (array([0, 0, 1], dtype=int64), array([0, 2, 0], dtype=int64))

　　當布爾數組直接作維下標時，至關於使用由nonzero()轉換以後的元組做爲下標對象：

b3 = np.arange(3*4*5).reshape(3,4,5)
res3 = b3[np.nonzero(b2)]
print(res3)
'''
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]]
'''

3，常見的矩陣運算

3.1，矩陣相乘（*）

　　就是矩陣的乘法操做，要求左邊矩陣的列和右邊矩陣的行數要一致

from numpy import  *
''' 1*2 的矩陣乘以2*1 的矩陣  獲得1*1 的矩陣'''

a1 = mat([1,2])
print(a1)
a2 = mat([[1],[2]])
print(a2)
a3 = a1*a2
print(a3)
'''
[[1 2]]
[[1]
 [2]]
[[5]]
'''

3.2，矩陣點乘（multiply）

　　矩陣點乘則要求矩陣必須維數相等，即M*N維矩陣乘以M*N維矩陣

from numpy import  *
''' 矩陣點乘爲對應矩陣元素相乘'''

a1 = mat([1,1])
print(a1)
a2 = mat([2,2])
print(a2)
a3 = multiply(a1,a2)
print(a3)
'''
[[1 1]]
[[2 2]]
[[2 2]]
'''


a1 = mat([2,2])
a2 = a1*2
print(a2)
# [[4 4]]

3.3，矩陣求逆變換（.I）

from numpy import *
''' 矩陣求逆變換:求矩陣matrix([[0.5,0],[0,0.5]])的逆矩陣'''

a1 = mat(eye(2,2)*0.5)
print(a1)
a2 = a1.I
print(a2)
'''
[[0.5 0. ]
 [0.  0.5]]
[[2. 0.]
 [0. 2.]]
'''

3.4，矩陣求轉置（.T）

from numpy import *
'''矩陣的轉置'''

a1 = mat([[1,1],[0,0]])
print(a1)
a2 = a1.T
print(a2)
'''
[[1 1]
 [0 0]]
[[1 0]
 [1 0]]
 '''

3.5，求矩陣對應列行的最大值，最小值，和。

　　計算每一列，行的和

from numpy import *
'''計算每一列，行的和'''

a1 = mat([[1,1],[2,3],[4,5]])
print(a1)
#  列和，這裏獲得的是1*2的矩陣
a2=a1.sum(axis=0)
print(a2)
'''
[[7 9]]
'''
#  行和，這裏獲得的是3*1的矩陣
a3=a1.sum(axis=1)
print(a3)
'''
[[2]
 [5]
 [9]]
 '''
#  計算第一行全部列的和，這裏獲得的是一個數值
a4=sum(a1[1,:])
print(a4)
'''
5
'''

　　計算最大，最小值和索引

from numpy import *
'''計算每一列，行的和'''

a1 = mat([[1,1],[2,3],[4,5]])
print(a1)
'''
[[1 1]
 [2 3]
 [4 5]]
'''
#  計算a1矩陣中全部元素的最大值,這裏獲得的結果是一個數值
maxa = a1.max()
print(maxa)   #5
#  計算第二列的最大值，這裏獲得的是一個1*1的矩陣
a2=max(a1[:,1])
print(a2)   #[[5]]
#  計算第二行的最大值，這裏獲得的是一個一個數值
maxt = a1[1,:].max()
print(maxt)   #3
#   計算全部列的最大值，這裏使用的是numpy中的max函數
maxrow = np.max(a1,0)
print(maxrow)   #[[4 5]]
# ;//計算全部行的最大值，這裏獲得是一個矩陣
maxcolumn = np.max(a1,1)
print(maxcolumn)
'''
[[1]
 [3]
 [5]]
'''
#  計算全部列的最大值對應在該列中的索引
maxindex = np.argmax(a1,0)
print(maxindex)   #[[2 2]]
#  計算第二行中最大值對應在改行的索引
tmaxindex = np.argmax(a1[1,:])
print(tmaxindex)  # 1

3.6，矩陣的分隔和合並　（vstack hstack）

　　矩陣的分割，同列表和數組的分割一致

from numpy import *
''' 矩陣的分隔，同列表和數組的分隔一致'''

a = mat(ones((3,3)))
print(a)
# 分隔出第二行之後的行和第二列之後的列的全部元素
b = a[1:,1:]
print(b)
'''
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
[[1. 1.]
 [1. 1.]]
'''

　　矩陣的合併

from numpy import *

a = mat(ones((2,2)))
print(a)
b = mat(eye(2))
print(b)
# 按照列和並，即增長行數
c = vstack((a,b))
print(c)
# 按照行合併，即行數不變，擴展列數
d = hstack((a,b))
print(d)
'''
[[1. 1.]
 [1. 1.]]
 
[[1. 0.]
 [0. 1.]]
 
[[1. 1.]
 [1. 1.]
 [1. 0.]
 [0. 1.]]
 
[[1. 1. 1. 0.]
 [1. 1. 0. 1.]]
'''

3.7 數組疊加合併

列合併/擴展：np.column_stack()
行合併/擴展：np.row_stack()

a = np.array((1,2,3,4))
b = np.array((11,22,33,44))
res1 = np.column_stack((a,b))
res2 = np.row_stack((a,b))
print(a)
print(b)
print(res1)
print(res2)
'''
[1 2 3 4]
[11 22 33 44]
[[ 1 11]
 [ 2 22]
 [ 3 33]
 [ 4 44]]
[[ 1  2  3  4]
 [11 22 33 44]]
 '''

3.8 數組均分（np.array.split()）

　　直接看例子：

x = np.arange(10)
res1 = np.array_split(x,2)
res2 = np.array_split(x,3)
print(res1)
print(res2)

'''
[array([0, 1, 2, 3, 4]), array([5, 6, 7, 8, 9])]
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8, 9])]
'''

3.9，矩陣，列表，數組的轉換

　　列表能夠修改，而且列表中元素可使不一樣類型的數據，以下：

li =[[1],'hello',3]

　　numpy中數組，同一個數組中全部元素必須爲同一個類型，有幾個常見的屬性：

from numpy import *

a=array([[2],[1]])
print(a )
dimension=a.ndim
m,n=a.shape
# 元素總個數
number=a.size
print(number)
# 2
#  元素的類型
str=a.dtype
print(str)
# int32

　　numpy中的矩陣也有與數組常見的幾個屬性，他們之間的轉換以下：

from numpy import *

# 列表
a1 = [[1,2],[3,2],[5,2]]
# 將列表轉化爲二維數組
a2 = array(a1)
# 將列表轉化成矩陣
a3 = mat(a1)
# 將矩陣轉化成數組
a4 = array(a3)
# 將矩陣轉換成列表
a5=a3.tolist()
# 將數組轉換成列表
a6=a2.tolist()
print(type(a1))
print(type(a2))
print(type(a3))
print(type(a4))
print(type(a5))
print(type(a6))
'''
<class 'list'>
<class 'numpy.ndarray'>
<class 'numpy.matrixlib.defmatrix.matrix'>
<class 'numpy.ndarray'>
<class 'list'>
<class 'list'>
'''

　　注意：當列表爲一維的時候，將他們轉換成數組和矩陣後，再經過tolist()轉換成列表是不相同的，這裏須要作一些小小的修改，以下：

from numpy import *

a1=[1,2,3]
print(a1)
print(type(a1))
a2=array(a1)
print(a2)
print(type(a2))
a3=mat(a1)
print(a3)
print(type(a3))
'''
[1, 2, 3]
<class 'list'>
[1 2 3]
<class 'numpy.ndarray'>
[[1 2 3]]
<class 'numpy.matrixlib.defmatrix.matrix'>

'''
a4=a2.tolist()
print(a4)
print(type(a4))
a5=a3.tolist()
print(a5)
print(type(a5))
'''
[1, 2, 3]
<class 'list'>
[[1, 2, 3]]
<class 'list'>
'''

a6=(a4 == a5)
print(a6)
print(type(a6))
a7=(a4 is a5[0])
print(a7)
print(type(a7))
'''
False
<class 'bool'>
False
<class 'bool'>
'''

　　矩陣轉換成數值，存在如下一種狀況：

from numpy import *

dataMat=mat([1])
print(dataMat)
print(type(dataMat))
'''
[[1]]
<class 'numpy.matrixlib.defmatrix.matrix'>
'''

# 這個時候獲取的就是矩陣的元素的數值，而再也不是矩陣的類型
val=dataMat[0,0]
print(val)
print(type(val))
'''
1
<class 'numpy.int32'>
'''

4,　matrix.getA()

　　getA()是numpy的一個函數，做用是將矩陣轉成一個ndarray，getA()函數和mat()函數的功能相反，是將一個矩陣轉化爲數組。

　　若是不轉，矩陣的每一個元素將沒法取出，會形成越界的問題，其具體解釋以下：

matrix.getA()
 　　Return self  as an ndarray object.
　　Equivalent to np.asarray(self)
Parameters:  None
Returns:    __ret_: ndarray
           self  as an  ndarray

　　舉例以下：

>>> x = np.matrix(np.arange(12).reshape((3,4))); x
matrix([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
>>> x.getA()
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

　　那麼爲何須要轉換呢？

　　由於在畫出數據集合的函數中，代碼以下（取自機器學習實戰Logistic迴歸最佳擬合直線的函數）

def plotBestFit(weights):
    weights = weights.getA()
    ...
    for i in range(n):
        #分類
        if int(labelMat[i]) == 1:
            xcord1.append(dataArr[i, 1])
            ycord1.append(dataArr[i, 2])
        else:
            xcord2.append(dataArr[i, 1])
            ycord2.append(dataArr[i, 2])

　　在這個代碼，咱們須要取出其中每一行每一列的值

若是是矩陣的話，咱們測試一下：

>>> b
matrix([[1, 2, 3, 4],
        [1, 2, 3, 4],
        [1, 2, 3, 4],
        [1, 2, 3, 4]])
>>> b[1][1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "D:\Python\lib\site-packages\numpy\matrixlib\defmatrix.py", line 284, in __getitem__
    out = N.ndarray.__getitem__(self, index)
IndexError: index 1 is out of bounds for axis 0 with size 1
>>>
>>> len(b[1])
1
>>> len(b[1][0])
1

　　能夠發現咱們取出矩陣的一行大小隻有1，若是你使用b[1][1]，b[1][2]之類的就會越界

　　當咱們轉爲np.array類型時

>>> c
array([[1, 2, 3, 4],
       [1, 2, 3, 4],
       [1, 2, 3, 4],
       [1, 2, 3, 4]])
>>> len(c[1])
4
>>> c[1][1]
2
>>>

　　能夠看出，咱們能夠取出任何一個值。

Python矩陣的切片

1，行操做

li = [[1,1],[1,3],[2,3],[4,4],[2,4]]
from numpy import *

a = [[1,2],[3,4],[5,6]]
a = mat(a)
# 打印整個矩陣
print(a[0:])
'''
[[1 2]
 [3 4]
 [5 6]]
 '''

# 打印矩陣E從1行開始到末尾行的內容
print(a[1:])
'''
[[3 4]
 [5 6]]  
'''

# 表示打印矩陣E 從1行到3行的內容
print(a[1:3])
'''
[[3 4]
 [5 6]]
 '''

2，列操做

li = [[1,1],[1,3],[2,3],[4,4],[2,4]]
from numpy import *
mat = mat(li)
# 在整個矩陣的基礎下，打印1列（指的是序列爲1的列
print(mat[:,0])
'''
[[1]
 [1]
 [2]
 [4]
 [2]]
'''
# 在矩陣的1行到2行（[1,3)） 的前提下打印兩列
# 2 列不是指兩列，而是序號爲2的列
print(mat[1:3,1])
'''
[[3]
 [3]]
 '''

Python numpy庫其餘函數用法

Numpy 的tile函數用法

　　tile函數位於Python模塊numpy.lib.shape_base中，他的功能是重複某個數組，好比 tile(A,reps)，功能是將數組A重複reps次，構成一個新的數組。

1，函數的定義與說明

　　函數格式爲 tile(A,reps)

　　A和reps 都是array_like

　　A的類型衆多，幾乎全部類型均可以：array list tuple dict matrix 以及基本數據類型Int string float 以及bool類型。

　　reps 的類型也不少，能夠是tuple list dict array int bool 但不能夠是float string matrix類型。

2，示例

  >>> a = np.array([0, 1, 2])
    >>> np.tile(a, 2)
    array([0, 1, 2, 0, 1, 2])
    >>> np.tile(a, (2, 2))
    array([[0, 1, 2, 0, 1, 2],
           [0, 1, 2, 0, 1, 2]])
    >>> np.tile(a, (2, 1, 2))
    array([[[0, 1, 2, 0, 1, 2]],
           [[0, 1, 2, 0, 1, 2]]])

    >>> b = np.array([[1, 2], [3, 4]])
    >>> np.tile(b, 2)
    array([[1, 2, 1, 2],
           [3, 4, 3, 4]])
    >>> np.tile(b, (2, 1))
    array([[1, 2],
           [3, 4],
           [1, 2],
           [3, 4]])

    >>> c = np.array([1,2,3,4])
    >>> np.tile(c,(4,1))
    array([[1, 2, 3, 4],
           [1, 2, 3, 4],
           [1, 2, 3, 4],
           [1, 2, 3, 4]])

from  numpy import *

code1 = tile(1,2)
print(code1)
# [1 1]

code2 = tile((1,2,3),3)
print(code2)
# [1 2 3 1 2 3 1 2 3]

a = [1,3,4]
code3 = tile(a,[2,3])
print(code3)
'''
[[1 3 4 1 3 4 1 3 4]
 [1 3 4 1 3 4 1 3 4]]
 '''

Numpy數據類型轉換astype dtype

1，查看數據類型

In [11]: arr = np.array([1,2,3,4,5])

In [12]: arr
Out[12]: array([1, 2, 3, 4, 5])

// 該命令查看數據類型
In [13]: arr.dtype
Out[13]: dtype('int64')

In [14]: float_arr = arr.astype(np.float64)

// 該命令查看數據類型
In [15]: float_arr.dtype
Out[15]: dtype('float64')

2，轉換數據類型

// 若是將浮點數轉換爲整數，則小數部分會被截斷
In [7]: arr2 = np.array([1.1, 2.2, 3.3, 4.4, 5.3221])

In [8]: arr2
Out[8]: array([ 1.1   ,  2.2   ,  3.3   ,  4.4   ,  5.3221])

// 查看當前數據類型
In [9]: arr2.dtype
Out[9]: dtype('float64')

// 轉換數據類型  float -> int
In [10]: arr2.astype(np.int32)
Out[10]: array([1, 2, 3, 4, 5], dtype=int32)

3，字符串數組轉換爲數值型

In [4]: numeric_strings = np.array(['1.2','2.3','3.2141'], dtype=np.string_)

In [5]: numeric_strings
Out[5]: array(['1.2', '2.3', '3.2141'], dtype='|S6')

// 此處寫的是float 而不是np.float64, Numpy很聰明，會將python類型映射到等價的dtype上
In [6]: numeric_strings.astype(float)
Out[6]: array([ 1.2, 2.3, 3.2141])

Numpy 範數的用法

　　顧名思義，linalg = linear + algebralinalg = linear + algebra , norm則表示範數，首先須要注意的是範數是對向量（或者矩陣）的度量，是一個標量（scalar）：

　　np.linalg.norm(求範數):linalg=linear（線性）+algebra（代數）

　　首先：help(np.linalg.norm) 查看其文檔：

norm(x, ord=None, axis=None, keepdims=False)

　　這裏咱們只對經常使用設置進行說明，x表示要度量的向量，ord表示範數的種類，axis表示向量的計算方向，keepdims表示設置是否保持維度不變。

用法：

import numpy as np

a=np.array([[complex(1,-1),3],[2,complex(1,1)]])  
print(a)


print(np.linalg.norm(a,ord=2) )   #計算矩陣2的範數


print(np.linalg.norm(a,ord=1) )   #計算矩陣1的範數


print(np.linalg.norm(a,ord=np.inf) )   #計算矩陣無窮的範數

示例：

import numpy as np
x = np.array([5,7])
np.linalg.norm(x)
8.602325267042627
np.linalg.norm(x,ord=2)
8.602325267042627
np.linalg.norm(x,ord=1)
12.0
np.linalg.norm(x,ord=np.inf)
7.0

　　範數理論告訴咱們，一範數 >= 二範數 >= 無窮範數

參考文獻：https://blog.csdn.net/taxueguilai1992/article/details/46581861

https://blog.csdn.net/lanchunhui/article/details/51004387