python如何创建不同元素的矩阵_Python numpy学习（2）——矩阵的用法
Python矩陣的基本用法
mat（）函數將目標數據的類型轉化成矩陣（matrix）
1，mat()函數和array()函數的區別
Numpy函數庫中存在兩種不同的數據類型（矩陣matrix和數組array），都可以用于處理行列表示的數字元素，雖然他們看起來很相似，但是在這兩個數據類型上執行相同的數學運算可能得到不同的結果，其中Numpy函數庫中的matrix與MATLAB中matrices等價。
直接看一個例子：
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))
結果：
[[1 3]
[5 7]]
[[1 2]
[3 4]]
[[1 3]
[4 5]]
首先，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]]
'''
# 使用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]]
'''
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函數用戶生成指定行數的單位矩陣
>>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='
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))
'''
'''
注意：當列表為一維的時候，將他們轉換成數組和矩陣后，再通過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]
[1 2 3]
[[1 2 3]]
'''
a4=a2.tolist()
print(a4)
print(type(a4))
a5=a3.tolist()
print(a5)
print(type(a5))
'''
[1, 2, 3]
[[1, 2, 3]]
'''
a6=(a4 == a5)
print(a6)
print(type(a6))
a7=(a4 is a5[0])
print(a7)
print(type(a7))
'''
False
False
'''
矩陣轉換成數值，存在以下一種情況：
from numpy import *
dataMat=mat([1])
print(dataMat)
print(type(dataMat))
'''
[[1]]
'''
# 這個時候獲取的就是矩陣的元素的數值，而不再是矩陣的類型
val=dataMat[0,0]
print(val)
print(type(val))
'''
1
'''
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 "", line 1, in
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
總結
以上是生活随笔為你收集整理的python如何创建不同元素的矩阵_Python numpy学习（2）——矩阵的用法的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python有哪些插件_Python和它
- 下一篇： 用python 中的链表 实现 截取其中