NumPy-1-26-中文文件-十一-

NumPy 1.26 中文文件（十一）

原文：numpy.org/doc/

numpy.fromstring

原文：numpy.org/doc/1.26/reference/generated/numpy.fromstring.html

numpy.fromstring(string, dtype=float, count=-1, *, sep, like=None)

從字串中的文字資料初始化的新 1-D 陣列。

引數：

stringstr

包含資料的字串。

dtype資料型別，可選項

陣列的資料型別；預設值：float。對於二進位制輸入資料，資料必須完全符合此格式。大多數內建的數值型別都受支援，擴充套件型別可能也受支援。

1.18.0 版的新功能：複雜的資料型別。

countint, 可選項

從資料中讀取此數量的dtype元素。如果這是負數（預設值），則計數將根據資料的長度確定。

sepstr, 可選項

分隔資料中數字的字串；元素之間的額外空白也將被忽略。

自 1.14 版本起已廢棄：傳遞sep=''，即預設值，已被棄用，因為它會觸發此函式的過時二進位制模式。此模式將string解釋為二進位制位元組，而不是包含十進位制數字的 ASCII 文字，在這種情況下更好拼寫為frombuffer(string, dtype, count)。如果string包含 unicode 文字，fromstring的二進位制模式確實會先使用 utf-8 將其編碼為位元組，這不會產生理智的結果。

likearray_like, 可選項

引用物件，允許建立不是 NumPy 陣列的陣列。如果傳入作為like支援__array_function__協議的類似陣列，結果將由其定義。在這種情況下，它確保建立與透過此引數傳入的相容的陣列物件。

1.20.0 版的新功能。

返回：

arrndarray

構建的陣列。

引發：

ValueError

如果字串不是滿足請求的dtype和count的正確尺寸。

參見

frombuffer, fromfile, fromiter

示例

>>> np.fromstring('1 2', dtype=int, sep=' ')
array([1, 2])
>>> np.fromstring('1, 2', dtype=int, sep=',')
array([1, 2]) 

numpy.ndarray.tofile

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.tofile.html

方法

ndarray.tofile(fid, sep='', format='%s')

將陣列寫入檔案作為文字或二進位制（預設）。

資料始終以“C”順序寫入，而與 a 的順序無關。透過此方法生成的資料可以使用 fromfile() 函式恢復。

引數：

fidfile 或 str 或 Path

一個開啟的檔案物件，或包含檔名的字串。

在版本 1.17.0 中更改：現在接受 pathlib.Path 物件。

sepstr

用於文字輸出的陣列項之間的分隔符。如果是“”（空），則寫入二進位制檔案，相當於 file.write(a.tobytes())。

formatstr

用於文字檔案輸出的格式字串。陣列中的每個條目都透過首先將其轉換為最接近的 Python 型別，然後使用“format” % item 來格式化為文字。

註釋

這是一個用於快速儲存陣列資料的便利函式。有關位元組序和精度的資訊將丟失，因此該方法不適合用於旨在存檔資料或在具有不同位元組序的機器之間傳輸資料的檔案。透過將資料輸出為文字檔案，可以克服其中一些問題，但會以速度和檔案大小為代價。

當 fid 是檔案物件時，陣列內容將直接寫入檔案，繞過檔案物件的 write 方法。因此，無法將 tofile 用於支援壓縮的檔案物件（例如 GzipFile）或不支援 fileno() 的檔案樣物件（例如 BytesIO）。

numpy.ndarray.tolist

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.tolist.html

方法

ndarray.tolist()

將陣列作為a.ndim級深度巢狀的 Python 標量列表返回。

將陣列資料作為（巢狀的）Python 列表的副本返回。資料項將轉換為最接近的相容內建 Python 型別，透過item函式。

如果a.ndim為 0，則由於巢狀列表的深度為 0，它根本不會是一個列表，而是一個簡單的 Python 標量。

引數：

none

返回：

y物件，或物件列表，或物件列表的列表，或…

可能巢狀的陣列元素列表。

注意

可能透過a = np.array(a.tolist())重新建立陣列，儘管這有時可能會丟失精度。

示例

對於一維陣列，a.tolist()幾乎與list(a)相同，只是tolist將 numpy 標量更改為 Python 標量：

>>> a = np.uint32([1, 2])
>>> a_list = list(a)
>>> a_list
[1, 2]
>>> type(a_list[0])
<class 'numpy.uint32'>
>>> a_tolist = a.tolist()
>>> a_tolist
[1, 2]
>>> type(a_tolist[0])
<class 'int'> 

另外，對於二維陣列，tolist會遞回應用：

>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]] 

這種遞迴的基本情況是 0 維陣列：

>>> a = np.array(1)
>>> list(a)
Traceback (most recent call last):
  ...
TypeError: iteration over a 0-d array
>>> a.tolist()
1 

numpy.array2string

原文：numpy.org/doc/1.26/reference/generated/numpy.array2string.html

numpy.array2string(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', style=<no value>, formatter=None, threshold=None, edgeitems=None, sign=None, floatmode=None, suffix='', *, legacy=None)

返回陣列的字串表示。

引數：

andarray

輸入陣列。

max_line_widthint，可選

如果文字超過max_line_width就插入換行符。預設為numpy.get_printoptions()['linewidth']。

precisionint 或 None，可選

浮點精度。預設為numpy.get_printoptions()['precision']。

suppress_smallbool，可選

將接近零的數字表示為零；預設為 False。接近的定義取決於精度：例如，如果精度為 8，小於 5e-9（絕對值）的數字將表示為零。預設為numpy.get_printoptions()['suppress']。

separatorstr，可選

在元素之間插入。

prefixstr，可選

suffixstr，可選

字首和字尾字串的長度分別用於對齊和換行輸出。陣列通常列印為：

prefix + array2string(a) + suffix 

輸出左邊填充了字首字串的長度，並且在列max_line_width - len(suffix)處強制換行。應注意字首和字尾字串的內容不包括在輸出中。

style_NoValue，可選

沒有效果，不要使用。

自版本 1.14.0 起廢棄。

formatter可呼叫的字典，可選

如果不是 None，則鍵應指示相應格式化函式適用於哪些型別。可呼叫函式應返回字串。透過預設格式化程式處理未指定（透過相應鍵）的型別。可以設定格式化程式的獨立型別包括：

• ‘bool’

• ‘int’

• ‘timedelta’：一個numpy.timedelta64

• ‘datetime’：一個numpy.datetime64

• ‘float’

• ‘longfloat’：128 位浮點數

• ‘complexfloat’

• ‘longcomplexfloat’：由兩個 128 位浮點陣列成

• ‘void’：型別numpy.void

• ‘numpystr’：型別numpy.bytes_和numpy.str_

可以用來一次設定一組型別的其他鍵有：

• ‘all’：設定所有型別

• ‘int_kind’：設定為‘int’

• ‘float_kind’：設定為‘float’和‘longfloat’

• ‘complex_kind’：設定為‘complexfloat’和‘longcomplexfloat’

• ‘str_kind’：設定為‘numpystr’

thresholdint，可選

陣列元素的總數，觸發摘要而不是完整 repr。預設為numpy.get_printoptions()['threshold']。

edgeitemsint，可選

每個維度初始和結尾的摘要中的陣列項數。預設為numpy.get_printoptions()['edgeitems']。

signstring，可以是‘-’，‘+’或‘ ’，可選

控制浮點型別的符號列印。如果為‘+’，則始終列印正值的符號。如果為‘ ’，則始終在正值的符號位置列印一個空格（空白字元）。如果為‘-’，則省略正值的符號字元。預設為numpy.get_printoptions()['sign']。

floatmode字串，可選

控制浮點型別的precision選項的解釋。預設為numpy.get_printoptions()['floatmode']。可以採用以下值：

• ‘fixed’: 總是精確列印precision個小數位數，即使這將列印多或少位數比唯一指定值所需的位數。

• ‘unique’: 列印表示每個值獨特性所需的最小小數位數。不同元素可能具有不同數量的數字。precision選項的值被忽略。

• ‘maxprec’: 最多列印precision個小數位數，但是如果元素可以用更少的位數唯一表示，則只對其使用少量位數。

• ‘maxprec_equal’: 最多列印precision個小數位數，但是如果陣列中的每個元素可以用更少的位數唯一表示，則對所有元素都使用該數量的位數。

legacy字串或False，可選

如果設定為字串‘1.13’，則啟用 1.13 版遺留列印模式。透過在浮點數的符號位置包括一個空格以及處理 0d 陣列的不同行為，來近似 numpy 1.13 版的列印輸出。如果設定為False，則禁用遺留模式。無法識別的字串將因前向相容性而受到警告而被忽略。

在 1.14.0 版中新增。

返回：

array_strstr

陣列的字串表示。

引發：

TypeError

如果formatter中的可呼叫物件不返回字串。

另請參閱

array_str, array_repr, set_printoptions, get_printoptions

注意

如果為某種型別指定了格式化程式，則該型別的precision關鍵字將被忽略。

這是一個非常靈活的函式；array_repr 和 array_str 在內部使用 array2string，因此具有相同名稱的關鍵字在這三個函式中應該以相同的方式工作。

示例

>>> x = np.array([1e-16,1,2,3])
>>> np.array2string(x, precision=2, separator=',',
...                       suppress_small=True)
'[0.,1.,2.,3.]' 

>>> x  = np.arange(3.)
>>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x})
'[0.00 1.00 2.00]' 

>>> x  = np.arange(3)
>>> np.array2string(x, formatter={'int':lambda x: hex(x)})
'[0x0 0x1 0x2]' 

numpy.array_repr

原文：numpy.org/doc/1.26/reference/generated/numpy.array_repr.html

numpy.array_repr(arr, max_line_width=None, precision=None, suppress_small=None)

返回陣列的字串表示。

引數：

arrndarray

輸入陣列。

max_line_widthint，可選

如果文字超過max_line_width，則插入換行符。預設為numpy.get_printoptions()['linewidth']。

precisionint，可選

浮點數精度。預設為numpy.get_printoptions()['precision']。

suppress_smallbool，可選

將“非常接近”零的數字表示為零；預設值為 False。非常接近由精度定義：例如，如果精度為 8，則絕對值小於 5e-9 的數字將表示為零。預設為numpy.get_printoptions()['suppress']。

返回：

stringstr

陣列的字串表示。

另請參閱

array_str, array2string, set_printoptions

示例

>>> np.array_repr(np.array([1,2]))
'array([1, 2])'
>>> np.array_repr(np.ma.array([0.]))
'MaskedArray([0.])'
>>> np.array_repr(np.array([], np.int32))
'array([], dtype=int32)' 

>>> x = np.array([1e-6, 4e-7, 2, 3])
>>> np.array_repr(x, precision=6, suppress_small=True)
'array([0.000001,  0\.      ,  2\.      ,  3\.      ])' 

numpy.array_str

原文：numpy.org/doc/1.26/reference/generated/numpy.array_str.html

numpy.array_str(a, max_line_width=None, precision=None, suppress_small=None)

返回陣列中資料的字串表示。

陣列中的資料以單個字串返回。此函式類似於array_repr，不同之處在於array_repr還返回有關陣列型別和資料型別的資訊。

引數：

andarray

輸入陣列。

max_line_widthint, 可選

如果文字長度超過max_line_width，則插入換行符。預設為numpy.get_printoptions()['linewidth']。

precisionint, 可選

浮點數精度。預設為numpy.get_printoptions()['precision']。

suppress_smallbool, 可選

將“接近”零的數字表示為零；預設為 False。非常接近根據精度定義：例如，如果精度為 8，則絕對值較小（絕對值）的數字小於 5e-9 將表示為零。預設為numpy.get_printoptions()['suppress']。

參見

array2string, array_repr, set_printoptions

示例

>>> np.array_str(np.arange(3))
'[0 1 2]' 

numpy.format_float_positional

原文：numpy.org/doc/1.26/reference/generated/numpy.format_float_positional.html

numpy.format_float_positional(x, precision=None, unique=True, fractional=True, trim='k', sign=False, pad_left=None, pad_right=None, min_digits=None)

將浮點標量格式化為十進位制字串的位置表示。

提供對四捨五入、修剪和填充的控制。使用並假設 IEEE 無偏舍入。使用“Dragon4”演算法。

引數：

x：Python 浮點數或 numpy 浮點標量

要格式化的值。

precision：非負整數或 None，可選

要列印的最大數字。如果unique是True，則可能為 None，但如果 unique 為False，則必須為整數。

unique：布林值，可選

如果True，則使用一種數字生成策略，該策略給出了從同型別的其他值中唯一識別該浮點數的最短表示形式，透過審慎舍入。如果給出precision比必要少的數字，可以列印更少，或者如果給出min_digits更多可以列印，這種情況下最後一個數字將以無偏舍入進行四捨五入。如果False，則生成的數字就像列印無限精度值並在列印precision位後停下，使用無偏舍入對剩餘值進行四捨五入

fractional：布林值，可選

如果True，precision和min_digits的截止時間指的是小數點後的總位數，包括前導零。如果False，precision和min_digits指的是小數點之前或之後的總有效數字，忽略前導零。

trim：‘k’、‘.’、‘0’、‘-’之一，可選

控制後處理修剪末尾數字的方式，如下：

• ‘k’：保留末尾的零，保留小數點（無修剪）

• ‘.’：修剪所有末尾的零，保留小數點

• ‘0’：修剪小數點前的所有零，如果缺少零，則插入零。

• ‘-’：去除末尾的零和任何末尾的小數點

sign：布林值，可選

是否顯示正值的符號。

pad_left：非負整數，可選

用空格填充字串的左側，直到小數點左側至少有這麼多的字元。

pad_right：非負整數，可選

用空格填充字串的右側，直到小數點右側至少有這麼多的字元。

min_digits：非負整數或 None，可選

要列印的最小數字。僅在unique=True時才有效，此時可能會列印額外的數字，超出必要的數字，對最後一個附加的數字四捨五入。

–版本新增：1.21.0

返回：

rep：字串

浮點值的字串表示

另請參見

format_float_scientific

示例

>>> np.format_float_positional(np.float32(np.pi))
'3.1415927'
>>> np.format_float_positional(np.float16(np.pi))
'3.14'
>>> np.format_float_positional(np.float16(0.3))
'0.3'
>>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
'0.3000488281' 

numpy.memmap

原文：numpy.org/doc/1.26/reference/generated/numpy.memmap.html

class numpy.memmap(filename, dtype=<class 'numpy.ubyte'>, mode='r+', offset=0, shape=None, order='C')

建立一個記憶體對映到儲存在磁碟上的二進位制檔案中的陣列。

記憶體對映檔案用於訪問磁碟上大檔案的小段，而無需將整個檔案讀入記憶體。NumPy 的 memmap 是類似陣列的物件。這與 Python 的mmap模組不同，後者使用類似檔案的物件。

這個 ndarray 的子類與一些操作有一些不愉快的互動，因為它不能完全適合作為一個子類。使用這個子類的一個替代方法是自己建立mmap物件，然後直接使用ndarray.__new__建立一個 ndarray，將建立的物件傳遞給它的‘buffer=’引數。

這個類可能在某個時候被轉變為一個工廠函式，返回一個對 mmap 緩衝區的檢視。

重新整理 memmap 例項以將更改寫入檔案。當前沒有 API 來關閉底層的mmap。確保資源實際上被關閉是棘手的，因為它可能在不同的 memmap 例項之間共享。

引數:

filenamestr、類檔案物件或 pathlib.Path 例項

用作陣列資料緩衝區的檔名或檔案物件。

dtype資料型別，可選

用於解釋檔案內容的資料型別。預設是uint8。

mode，可選

檔案以這種模式開啟：

‘r’	只讀開啟現有檔案。
‘r+’	開啟現有檔案以供讀取和寫入。
‘w+’	為讀寫建立或覆蓋現有檔案。如果mode == 'w+'，則必須指定shape。
‘c’	寫時複製：賦值將影響記憶體中的資料，但更改不會儲存到磁碟。磁碟上的檔案是隻讀的。

預設是‘r+’。

offset整數，可選

在檔案中，陣列資料從這個偏移開始。由於offset以位元組為單位，所以通常應該是dtype的位元組大小的倍數。當mode != 'r'時，甚至在檔案末端之後的正偏移也是有效的；檔案將被擴充套件以容納額外的資料。預設情況下，memmap會從檔案的開頭開始，即使filename是一個檔案指標fp並且fp.tell() != 0也是如此。

shape元組，可選

陣列的期望形狀。如果mode == 'r'並且offset之後剩餘的位元組數不是dtype的位元組大小的倍數，您必須指定shape。預設情況下，返回的陣列將是 1-D，元素數量由檔案大小和資料型別確定。

order，可選

指定 ndarray 記憶體佈局的順序: 行主序，C 風格或列主序，Fortran 風格。只有在形狀大於 1-D 時才會生效。預設順序是'C'。

另請參閱

lib.format.open_memmap

建立或載入記憶體對映的.npy檔案。

註釋

記憶體對映物件可以在任何接受 ndarray 的地方使用。給定記憶體對映fp，isinstance(fp, numpy.ndarray) 返回True。

32 位系統上記憶體對映檔案的大小不能超過 2GB。

當記憶體對映導致檔案在檔案系統中建立或擴充套件到當前大小之外時，新部分的內容是未指定的。在具有 POSIX 檔案系統語義的系統上，擴充套件部分將填充為零位元組。

示例

>>> data = np.arange(12, dtype='float32')
>>> data.resize((3,4)) 

此示例使用臨時檔案，以便 doctest 不會將檔案寫入您的目錄。您可以使用“常規”檔名。

>>> from tempfile import mkdtemp
>>> import os.path as path
>>> filename = path.join(mkdtemp(), 'newfile.dat') 

建立一個 dtype 和形狀與我們的資料相匹配的記憶體對映:

>>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))
>>> fp
memmap([[0., 0., 0., 0.],
 [0., 0., 0., 0.],
 [0., 0., 0., 0.]], dtype=float32) 

將資料寫入記憶體對映陣列:

>>> fp[:] = data[:]
>>> fp
memmap([[  0.,   1.,   2.,   3.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32) 

>>> fp.filename == path.abspath(filename)
True 

將記憶體中的更改重新整理到磁碟，以便讀取。

>>> fp.flush() 

載入記憶體對映並驗證資料已儲存:

>>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
>>> newfp
memmap([[  0.,   1.,   2.,   3.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32) 

只讀記憶體對映:

>>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
>>> fpr.flags.writeable
False 

寫時複製的記憶體對映:

>>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
>>> fpc.flags.writeable
True 

可以對寫時複製陣列進行賦值，但值只會寫入陣列的記憶體副本，不會寫入磁碟：

>>> fpc
memmap([[  0.,   1.,   2.,   3.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32)
>>> fpc[0,:] = 0
>>> fpc
memmap([[  0.,   0.,   0.,   0.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32) 

磁碟上的檔案不變:

>>> fpr
memmap([[  0.,   1.,   2.,   3.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32) 

記憶體對映的偏移量:

>>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
>>> fpo
memmap([  4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.], dtype=float32) 

屬性：

filenamestr 或 pathlib.Path 例項

對映檔案的路徑。

offset整數

檔案中的偏移位置。

mode字串

檔案模式。

方法

flush()	將陣列中的任何更改寫入磁碟上的檔案。

numpy.lib.format.open_memmap

原文：numpy.org/doc/1.26/reference/generated/numpy.lib.format.open_memmap.html

lib.format.open_memmap(filename, mode='r+', dtype=None, shape=None, fortran_order=False, version=None, *, max_header_size=10000)

開啟一個.npy 檔案作為記憶體對映的陣列。

可用於讀取現有檔案或建立新檔案。

引數：

filename字串或類似路徑的物件

磁碟上的檔名。這可能不是類似檔案的物件。

mode字串，可選

開啟檔案的模式；預設值為‘r+’。除了標準檔案模式外，‘c’也可表示“寫時複製”。有關可用模式字串，請參見memmap。

dtype資料型別，可選

如果我們在“寫”模式下建立新檔案，此為陣列的資料型別，如果不是，則忽略dtype。預設值為 None，導致資料型別為float64。

形狀整數的元組

如果我們在“寫”模式下建立新檔案，則為陣列的形狀，此時此引數是必需的。否則，此引數將被忽略，因此是可選的。

fortran_order布林值，可選

如果我們在“寫”模式下建立新檔案，則陣列應該是 Fortran 連續的（True）還是 C 連續的（False，預設）。

version整數的元組（主要，次要）或 None

如果模式是“寫”模式，那麼這是用於建立檔案的檔案格式的版本。None 表示使用能夠儲存資料的最舊支援的版本。預設值：None

max_header_size整數，可選

頭部的最大允許大小。大頭部可能不安全，因此需要顯式傳遞一個更大的值。有關詳情，請參見ast.literal_eval。

返回：

marray記憶體對映

記憶體對映陣列。

引發：

ValueError

如果資料或模式無效。

OSError

如果未找到檔案或無法正確開啟檔案。

另見

numpy.memmap

numpy.set_printoptions

原文：numpy.org/doc/1.26/reference/generated/numpy.set_printoptions.html

numpy.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, *, legacy=None)

設定列印選項。

這些選項決定了浮點數、陣列和其他 NumPy 物件的顯示方式。

引數：

精度整數或 None，可選

浮點數輸出精度的位數（預設 8）。如果 floatmode 不是 fixed，則可以為 None，以列印出足夠唯一指定數值所需的位數。

閾值整數，可選

觸發摘要顯示而不是完整表示的陣列元素的總數（預設 1000）。要始終使用完整表示而不用摘要，傳遞 sys.maxsize。

edgeitems整數，可選

每個維度的開始和結束處彙總的陣列項數（預設 3）。

linewidth整數，可選

每行字元數，用於插入換行符（預設 75）。

suppress布林值，可選

如果為 True，則總是使用固定點表示法列印浮點數，此時在當前精度下等於零的數將列印為零。如果為 False，則當最小數的絕對值 < 1e-4 或最大絕對值與最小絕對值的比率 > 1e3 時，使用科學計數法。預設值為 False。

nanstr字串，可選

浮點數的非數字的字串表示（預設 nan）。

infstr字串，可選

浮點數無窮的字串表示（預設 inf）。

符號字串，‘-’、‘+’或‘’，可選

控制浮點型別的符號列印。如果為‘+’，總是列印正值的符號。如果為‘ ’，總是在正值的符號位置列印一個空格（空白字元）。如果為‘-’，省略正值的符號字元（預設‘-’）

格式化器可呼叫的字典，可選

如果不為 None，則鍵應指示相應格式化函式適用於的型別。可呼叫物件應返回一個字串。未透過指定（由其相應鍵）的型別由預設格式化器處理。可以設定格式化器的個別型別是：

• ‘bool’

• ‘int’

• ‘timedelta’：numpy.timedelta64

• ‘datetime’：numpy.datetime64

• ‘float’

• ‘longfloat’：128 位浮點數

• ‘complexfloat’

• ‘longcomplexfloat’：由兩個 128 位浮點陣列成

• ‘numpystr’：型別numpy.bytes_和numpy.str_

• ‘object’：np.object_ 陣列

可用的其他鍵可以用於一次設定一組型別：

• ‘all’：設定所有型別

• ‘int_kind’：設定‘int’

• ‘float_kind’：設定‘float’和‘longfloat’

• ‘complex_kind’：設定‘complexfloat’和‘longcomplexfloat’

• ‘str_kind’：設定‘numpystr’

floatmode字串，可選

控制浮點型別的precision選項的解釋。可以取以下值（預設值為 maxprec_equal）：

• ‘fixed’: 總是精確列印precision個小數位，

  即使有可能列印的位數多或少於唯一指定該值所需的位數。

• ‘unique’: 只列印為了指定值所需的最少小數位數

  以唯一方式表示每個值。不同的元素可以有不同數量的位數。忽略precision選項的值。

• ‘maxprec’: 最多列印precision個小數位，但如果

  一個元素如果只需較少的數字就能唯一表示，則只列印對應數量的數字。

• ‘maxprec_equal’: 最多列印precision個小數位，

  但如果陣列中的每個元素都可以用較少的相等數字唯一表示，則所有元素都使用同樣數量的數字。

legacy字串或False，可選

如果設為字串‘1.13’則啟用 1.13 版的舊版列印模式。這樣可以透過在浮點數的符號位置包含一個空格以及對 0 維陣列有不同的行為來近似 numpy 1.13 版本的列印輸出。這也啟用了 1.21 版的舊版列印模式（下面有描述）。

如果設為字串‘1.21’則啟用 1.21 版的舊版列印模式。這樣可以透過不在逗號後面和冒號後面插入空格來近似 numpy 1.21 版本對複雜結構資料型別的列印輸出。

如果設為False，則禁用舊版模式。

無法識別的字串將被忽略，並給出警告以保持向前相容性。

新版本為 1.14.0。

從 1.22.0 版本開始發生變化。

另請參見

get_printoptions, printoptions, set_string_function, array2string

注意

formatter總是透過呼叫set_printoptions來重設的。

使用printoptions作為上下文管理器臨時設定值。

示例

浮點數精度可以設定：

>>> np.set_printoptions(precision=4)
>>> np.array([1.123456789])
[1.1235] 

可以概要顯示長陣列：

>>> np.set_printoptions(threshold=5)
>>> np.arange(10)
array([0, 1, 2, ..., 7, 8, 9]) 

可以抑制小結果：

>>> eps = np.finfo(float).eps
>>> x = np.arange(4.)
>>> x**2 - (x + eps)**2
array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
>>> np.set_printoptions(suppress=True)
>>> x**2 - (x + eps)**2
array([-0., -0.,  0.,  0.]) 

可以使用自定義格式化程式來顯示所需的陣列元素：

>>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
>>> x = np.arange(3)
>>> x
array([int: 0, int: -1, int: -2])
>>> np.set_printoptions()  # formatter gets reset
>>> x
array([0, 1, 2]) 

若要恢復預設選項，可以使用：

>>> np.set_printoptions(edgeitems=3, infstr='inf',
... linewidth=75, nanstr='nan', precision=8,
... suppress=False, threshold=1000, formatter=None) 

也可以使用printoptions作為上下文管理器臨時覆蓋選項：

>>> with np.printoptions(precision=2, suppress=True, threshold=5):
...     np.linspace(0, 10, 10)
array([ 0\.  ,  1.11,  2.22, ...,  7.78,  8.89, 10\.  ]) 

numpy.get_printoptions

原文：numpy.org/doc/1.26/reference/generated/numpy.get_printoptions.html

numpy.get_printoptions()

返回當前列印選項。

返回：

print_opts字典

具有鍵的當前列印選項字典

• precision : 整數
• threshold : 整數
• edgeitems : 整數
• linewidth : 整數
• suppress : 布林值
• nanstr : 字串
• infstr : 字串
• formatter : 函式字典
• sign : 字串

有關這些選項的詳細描述，請參見set_printoptions。

另請參閱

set_printoptions, printoptions, set_string_function

numpy.set_string_function

原文：numpy.org/doc/1.26/reference/generated/numpy.set_string_function.html

numpy.set_string_function(f, repr=True)

設定在美觀列印陣列時使用的 Python 函式。

引數:

f 函式或 None

用於美觀列印陣列的函式。該函式應該期望一個單一的陣列引數，並返回陣列表示的字串。如果為 None，則該函式將重置為預設的 NumPy 函式以列印陣列。

repr 布林值，可選

如果為 True（預設值），則設定用於美觀列印（__repr__）的函式，如果為 False，則設定返回預設字串表示（__str__）的函式。

另請參閱

set_printoptions, get_printoptions

示例

>>> def pprint(arr):
...     return 'HA! - What are you going to do now?'
...
>>> np.set_string_function(pprint)
>>> a = np.arange(10)
>>> a
HA! - What are you going to do now?
>>> _ = a
>>> # [0 1 2 3 4 5 6 7 8 9] 

我們可以將函式重置為預設值：

>>> np.set_string_function(None)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

repr 影響美觀列印或正常字串表示。請注意，透過設定 __str__ 仍然會影響 __repr__，因為返回的字串中每個陣列元素的寬度變為 __str__() 結果的長度。

>>> x = np.arange(4)
>>> np.set_string_function(lambda x:'random', repr=False)
>>> x.__str__()
'random'
>>> x.__repr__()
'array([0, 1, 2, 3])' 

numpy.printoptions

原文：numpy.org/doc/1.26/reference/generated/numpy.printoptions.html

numpy.printoptions(*args, **kwargs)

用於設定列印選項的上下文管理器。

在with塊的範圍內設定列印選項，並在結束時恢復舊選項。有關可用選項的完整描述，請參閱set_printoptions。

另請參閱

set_printoptions，get_printoptions

示例

>>> from numpy.testing import assert_equal
>>> with np.printoptions(precision=2):
...     np.array([2.0]) / 3
array([0.67]) 

with語句的as子句提供當前的列印選項：

>>> with np.printoptions(precision=2) as opts:
...      assert_equal(opts, np.get_printoptions()) 

numpy.binary_repr

原文：numpy.org/doc/1.26/reference/generated/numpy.binary_repr.html

numpy.binary_repr(num, width=None)

將輸入數字的二進位制表示作為字串返回。

對於負數，如果未給定 width，則在前面新增負號。如果給定了 width，則返回該數字的二進位制補碼，相對於該寬度。

在二進位制補碼系統中，負數由絕對值的補碼錶示。這是計算機上表示帶符號整數的最常見方法[1]。 N 位二進位制補碼系統可以表示範圍在(-2^{N-1})到( +2^{N-1}-1)中的每個整數。

引數：

numint

只能使用整數十進位制數。

widthint，可選

如果 num 為正數，則返回的字串的長度，或者如果 num 為負數，則返回的二進位制補碼的長度，條件是 width 至少為表示 num 所需的指定形式的位數。

如果 width 值不夠，它將被忽略，並且 num 將以二進位制（num > 0）或二進位制補碼（num < 0）的形式返回，其寬度等於表示以指定形式表示該數字所需的最小位數。此行為已不推薦使用，以後將會報錯。

自版本 1.12.0 起已棄用。

返回：

binstr

num 的二進位制表示或 num 的二進位制補碼。

亦參見

base_repr

返回給定基數系統中數字的字串表示。

bin

Python 內建的整數二進位制表示生成器。

注

binary_repr 等同於使用 base_repr 以基數為 2，但約快 25 倍。

參考

[1]

維基百科，“二進位制補碼”，zh.wikipedia.org/wiki/二進位制補碼

示例

>>> np.binary_repr(3)
'11'
>>> np.binary_repr(-3)
'-11'
>>> np.binary_repr(3, width=4)
'0011' 

當輸入數字為負數且指定了寬度時，返回二進位制補碼：

>>> np.binary_repr(-3, width=3)
'101'
>>> np.binary_repr(-3, width=5)
'11101' 

numpy.base_repr

原文：numpy.org/doc/1.26/reference/generated/numpy.base_repr.html

numpy.base_repr(number, base=2, padding=0)

返回給定基數系統中數字的字串表示。

引數：

numberint

要轉換的值。處理正負值。

baseint，可選

將number轉換為base數字系統。有效範圍為 2-36，預設值為 2。

paddingint，可選

左側填充的零的數量。預設為 0（無填充）。

返回：

outstr

在base系統中number的字串表示。

參見

binary_repr

用於基數為 2 的快速版本base_repr。

示例

>>> np.base_repr(5)
'101'
>>> np.base_repr(6, 5)
'11'
>>> np.base_repr(7, base=5, padding=3)
'00012' 

>>> np.base_repr(10, base=16)
'A'
>>> np.base_repr(32, base=16)
'20' 

numpy.DataSource

原文：numpy.org/doc/1.26/reference/generated/numpy.DataSource.html

class numpy.DataSource(destpath='.')

通用資料來源檔案（檔案，http，ftp，…）。

資料來源可以是本地檔案或遠端檔案/URL。檔案也可以是壓縮或未壓縮的。DataSource 隱藏了一些下載檔案的底層細節，允許您簡單地傳入有效的檔案路徑（或 URL）並獲取檔案物件。

引數：

destpathstr 或 None，可選

原始檔下載到的目錄路徑以供使用。如果destpath為 None，則將建立一個臨時目錄。預設路徑為當前目錄。

注意

URL 需要使用方案字串（http://）才能正常使用，否則它們將失敗：

>>> repos = np.DataSource()
>>> repos.exists('www.google.com/index.html')
False
>>> repos.exists('http://www.google.com/index.html')
True 

當 DataSource 被刪除時，臨時目錄也會被刪除。

示例

>>> ds = np.DataSource('/home/guido')
>>> urlname = 'http://www.google.com/'
>>> gfile = ds.open('http://www.google.com/')
>>> ds.abspath(urlname)
'/home/guido/www.google.com/index.html'

>>> ds = np.DataSource(None)  # use with temporary file
>>> ds.open('/home/guido/foobar.txt')
<open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430>
>>> ds.abspath('/home/guido/foobar.txt')
'/tmp/.../home/guido/foobar.txt' 

方法

abspath(path)	返回 DataSource 目錄中檔案的絕對路徑。
exists(path)	檢查路徑是否存在。
open(path[, mode, encoding, newline])	開啟並返回類似檔案的物件。

numpy.lib.format

原文：numpy.org/doc/1.26/reference/generated/numpy.lib.format.html

二進位制序列化

NPY 格式

一個簡單的格式，用於將 NumPy 陣列儲存到磁碟，幷包含有關它們的完整資訊。

.npy 格式是 NumPy 中用於將單個任意 NumPy 陣列持久化到磁碟的標準二進位制檔案格式。該格式儲存了重建陣列所需的所有形狀和資料型別資訊，即使在具有不同架構的另一臺機器上也能正確重建陣列。該格式旨在儘可能簡單，同時實現其有限的目標。

.npz 格式是將多個 NumPy 陣列持久化到磁碟的標準格式。一個.npz檔案是一個 zip 檔案，包含多個.npy檔案，每個檔案對應一個陣列。

能力

• 可以表示所有 NumPy 陣列，包括巢狀記錄陣列和物件陣列。

• 以其本機二進位制形式表示資料。

• 直接支援 Fortran 連續陣列。

• 儲存了重建陣列所需的所有資訊，包括在不同架構的機器上的形狀和資料型別。支援小端和大端陣列，具有小端數字的檔案將在任何讀取該檔案的機器上產生小端陣列。型別是根據它們的實際大小描述的。例如，如果一個具有 64 位 C “long int”的機器寫出一個帶有“long ints”的陣列，那麼一個具有 32 位 C “long ints”的讀取機器將產生一個帶有 64 位整數的陣列。

• 容易被逆向工程。資料集通常比建立它們的程式存在時間更長。一個稱職的開發者應該能夠用他們喜歡的程式語言建立一個解決方案，以讀取大部分沒有太多文件的.npy檔案。

• 允許記憶體對映資料。參見open_memmap。

• 可以從類似檔案的流物件而不是實際檔案中讀取。

• 儲存物件陣列，即包含任意 Python 物件的陣列。具有物件陣列的檔案不能進行記憶體對映，但可以讀取和寫入磁碟。

限制

• numpy.ndarray 的任意子類並不完全保留。子類將被接受用於寫入，但只有陣列資料將被寫出。在讀取檔案時將建立一個常規的 numpy.ndarray 物件。

警告

由於對結構化資料型別的解釋存在限制，具有空名稱欄位的資料型別將被替換為‘f0’、‘f1’等。這樣的陣列將無法完全準確地透過格式迴圈。資料是完整的；只有欄位名稱會有所不同。我們正在努力解決這個問題。這個修復不需要更改檔案格式。具有這種結構的陣列仍然可以儲存和恢復，並且可以透過使用loadedarray.view(correct_dtype)方法恢復正確的資料型別。

副檔名

我們建議使用.npy和.npz副檔名儲存此格式的檔案。這絕不是必須的；應用程式可能希望使用這些檔案格式，但使用特定於應用程式的副檔名。然而，在沒有明顯替代方案的情況下，我們建議使用.npy和.npz。

版本編號

這些格式的版本編號與 NumPy 版本編號是獨立的。如果格式升級，numpy.io中的程式碼仍將能夠讀取和寫入版本 1.0 檔案。

格式版本 1.0

前 6 個位元組是一個魔術字串：正好為\x93NUMPY。

接下來的 1 個位元組是無符號位元組：檔案格式的主要版本號，例如\x01。

接下來的 1 個位元組是無符號位元組：檔案格式的次要版本號，例如\x00。注意：檔案格式的版本與 numpy 軟體包的版本無關。

接下來的 2 個位元組形成一個小端無符號短整型：頭資料 HEADER_LEN 的長度。

接下來的 HEADER_LEN 位元組形成描述陣列格式的頭資料。這是一個 ASCII 字串，包含一個字典的 Python 文字表示式。它以換行符（\n）結尾，並用空格（\x20）填充，使得len(magic string) + 2 + len(length) + HEADER_LEN的總和能夠被 64 整除，以��對齊。

字典包含三個鍵：

“descr”dtype.descr

可作為引數傳遞給numpy.dtype建構函式以建立陣列 dtype 的物件。

“fortran_order”布林值

陣列資料是否是 Fortran 連續的。由於 Fortran 連續陣列是一種常見的非 C 連續形式，我們允許它們直接寫入磁碟以提高效率。

“shape”整數元組

陣列的形狀。

為了重複性和可讀性，字典鍵按字母順序排序。這僅為方便起見。作者應儘可能實現這一點。讀者不應依賴於此。

在頭部之後是陣列資料。如果 dtype 包含 Python 物件（即dtype.hasobject is True），則資料是陣列的 Python pickle。否則，資料是陣列的連續（無論是 C 還是 Fortran，取決於fortran_order）位元組。消費者可以透過將形狀給定的元素數量相乘（注意shape=()表示有 1 個元素）乘以dtype.itemsize來計算位元組數。

格式版本 2.0

版本 1.0 格式僅允許陣列頭的總大小為 65535 位元組。結構化陣列的列數較多時可能會超過此限制。版本 2.0 格式將頭大小擴充套件到 4 GiB。numpy.save將根據資料的需要自動儲存為 2.0 格式，否則將始終使用更相容的 1.0 格式。

因此，頭的第四個元素的描述變為：“接下來的 4 個位元組形成一個小端無符號整型：頭資料 HEADER_LEN 的長度。”

格式版本 3.0

這個版本用 utf8 編碼的字串替換了 ASCII 字串（實際上是 latin1），因此支援具有任何 Unicode 欄位名稱的結構化型別。

注意

.npy 格式，包括建立動機和替代方案的比較，在 “npy-format” NEP 中有描述，但隨著時間的推移，細節已經發生變化，本文件更為當前。

函式

descr_to_dtype(descr)	根據給定描述返回 dtype。
dtype_to_descr(dtype)	從 dtype 獲取可序列化的描述符。
header_data_from_array_1_0(array)	從 numpy.ndarray 獲取頭部後設資料的字典。
magic(major, minor)	返回給定檔案格式版本的魔術字串。
open_memmap(filename[, mode, dtype, shape, ...])	將 .npy 檔案作為記憶體對映陣列開啟。
read_array(fp[, allow_pickle, ...])	從 NPY 檔案中讀取陣列。
read_array_header_1_0(fp[, max_header_size])	使用 1.0 檔案格式版本從檔案物件中讀取陣列頭。
read_array_header_2_0(fp[, max_header_size])	使用 2.0 檔案格式版本從檔案物件中讀取陣列頭。
read_magic(fp)	讀取魔術字串以獲取檔案格式的版本。
write_array(fp, array[, version, ...])	將陣列寫入 NPY 檔案，包括頭部。
write_array_header_1_0(fp, d)	使用 1.0 格式寫入陣列頭。
write_array_header_2_0(fp, d)	使用 2.0 格式寫入陣列頭。

NPY 格式

用於將 numpy 陣列儲存到磁碟的簡單格式，包含有關它們的所有資訊。

.npy 格式是 NumPy 中用於在磁碟上持久化單個任意 NumPy 陣列的標準二進位制檔案格式。該格式儲存了重建陣列所需的所有形狀和 dtype 資訊，即使在具有不同架構的另一臺機器上也能正確重建陣列。該格式旨在儘可能簡單，同時實現其有限的目標。

.npz 格式是在磁碟上持久化多個 NumPy 陣列的標準格式。一個 .npz 檔案是一個 zip 檔案，包含多個 .npy 檔案，每個檔案對應一個陣列。

能力

• 可以表示所有 NumPy 陣列，包括巢狀記錄陣列和物件陣列。

• 以其本機二進位制形式表示資料。

• 直接支援 Fortran 連續陣列。

• 儲存了重建陣列所需的所有資訊，包括形狀和 dtype，在具有不同架構的機器上。支援小端和大端陣列，並且具有小端數字的檔案將在讀取檔案的任何機器上產生小端陣列。型別是根據其實際大小描述的。例如，如果具有 64 位 C “long int”的機器寫出一個帶有“long ints”的陣列，那麼具有 32 位 C “long ints”的讀取機器將產生一個帶有 64 位整數的陣列。

• 易於逆向工程。資料集通常比建立它們的程式存在時間更長。一位稱職的開發人員應該能夠使用他們喜歡的程式語言建立一個解決方案，以讀取大部分給定的 .npy 檔案而無需太多文件。

• 允許對資料進行記憶體對映。參見 open_memmap。

• 可以從類似檔案流物件而不是實際檔案中讀取。

• 儲存物件陣列，即包含任意 Python 物件的陣列。具有物件陣列的檔案不能進行記憶體對映，但可以讀取和寫入磁碟。

限制

• 任意的 numpy.ndarray 子類並不完全保留。子類將被接受進行寫入，但只有陣列資料將被寫出。在讀取檔案時將建立一個常規的 numpy.ndarray 物件。

警告

由於對結構化 dtypes 的解釋存在限制，具有空名稱欄位的 dtypes 將其名稱替換為‘f0’、‘f1’等。這樣的陣列將無法完全準確地透過格式迴圈。資料完整；只有欄位名稱會有所不同。我們正在努力解決這個問題。這個修復不需要更改檔案格式。具有這種結構的陣列仍然可以儲存和恢復，並且可以透過使用 loadedarray.view(correct_dtype) 方法恢復正確的 dtype。

副檔名

我們建議使用.npy和.npz副檔名儲存以這種格式儲存的檔案。這絕不是一個要求；應用程式可能希望使用這些檔案格式，但使用特定於應用程式的副檔名。然而，在沒有明顯替代方案的情況下，我們建議使用.npy和.npz。

版本編號

這些格式的版本編號與 NumPy 版本編號無關。如果格式升級，numpy.io中的程式碼仍將能夠讀取和寫入版本 1.0 檔案。

格式版本 1.0

前 6 個位元組是一個魔術字串：確切地為\x93NUMPY。

下一個位元組是一個無符號位元組：檔案格式的主版本號，例如\x01。

下一個位元組是一個無符號位元組：檔案格式的次版本號，例如\x00。注意：檔案格式的版本與 numpy 軟體包的版本無關。

接下來的 2 個位元組形成一個小端無符號短整數：頭部資料 HEADER_LEN 的長度。

接下來的 HEADER_LEN 位元組形成描述陣列格式的頭部資料。這是一個 ASCII 字串，其中包含一個字典的 Python 文字表示式。它以換行符（\n）結尾，並用空格（\x20）填充，使得len(magic string) + 2 + len(length) + HEADER_LEN的總和能夠被 64 整除，以便對齊。

字典包含三個鍵：

“descr”dtype.descr

一個可以作為引數傳遞給numpy.dtype建構函式以建立陣列 dtype 的物件。

“fortran_order”布林值

陣列資料是否是 Fortran 連續的。由於 Fortran 連續陣列是一種常見的非 C 連續形式，我們允許它們直接寫入磁碟以提高效率。

“shape”整數元組

陣列的形狀。

為了重複性和可讀性，字典鍵按字母順序排序。這僅供方便。如果可能的話，寫入者應該實現這一點。讀者不應該依賴於此。

在頭部之後是陣列資料。如果 dtype 包含 Python 物件（即dtype.hasobject為 True），那麼資料是陣列的 Python pickle。否則，資料是陣列的連續（無論是 C 還是 Fortran，取決於fortran_order）位元組。消費者可以透過將形狀給定的元素數乘以dtype.itemsize來計算位元組數（注意shape=()表示有 1 個元素）。

格式版本 2.0

版本 1.0 格式只允許陣列頭部的總大小為 65535 位元組。這可以被具有大量列的結構化陣列超過。版本 2.0 格式將頭部大小擴充套件到 4 GiB。如果資料需要，numpy.save將自動儲存為 2.0 格式，否則它將始終使用更相容的 1.0 格式。

因此，頭部的第四個元素的描述變為：“接下來的 4 個位元組形成一個小端無符號整數：頭部資料 HEADER_LEN 的長度。”

格式版本 3.0

此版本將 ASCII 字串（實際上是 latin1）替換為 utf8 編碼的字串，因此支援具有任何 Unicode 欄位名稱的結構化型別。

注意事項

描述了.npy格式，包括建立動機和與其他格式的比較，在“npy-format” NEP中，然而細節隨著時間的推移而發展，這份文件更為當前。

功能

• 可以表示所有 NumPy 陣列，包括巢狀記錄陣列和物件陣列。

• 以其本機二進位制形式表示資料。

• 直接支援 Fortran 連續陣列。

• 儲存重建陣列所需的所有資訊，包括在不同架構的機器上的形狀和資料型別。支援小端和大端陣列，並且具有小端數字的檔案將在任何讀取檔案的機器上產生小端陣列。型別是根據它們的實際大小描述的。例如，如果一個具有 64 位 C “long int”的機器寫出一個帶有“long ints”的陣列，那麼一個具有 32 位 C “long ints”的讀取機器將產生一個帶有 64 位整數的陣列。

• 易於逆向工程。資料集通常比建立它們的程式存在時間更長。一位稱職的開發人員應該能夠使用他們喜歡的程式語言建立一個解決方案，以讀取大多數給定的.npy檔案而無需太多文件。

• 允許對資料進行記憶體對映。請參閱open_memmap。

• 可以從類似檔案流物件而不是實際檔案中讀取。

• 儲存物件陣列，即包含任意 Python 物件的陣列。具有物件陣列的檔案不可進行記憶體對映，但可以讀取和寫入磁碟。

限制

• 任意的 numpy.ndarray 子類不會完全保留。子類將被接受進行寫入，但只有陣列資料將被寫出。在讀取檔案時將建立一個常規的 numpy.ndarray 物件。

警告

由於對結構化資料型別的解釋存在限制，具有空欄位名稱的資料型別將被替換為‘f0’、‘f1’等。這樣的陣列將無法完全準確地迴圈透過格式。資料是完整的；只有欄位名稱會有所不同。我們正在努力解決這個問題。這個修復不需要更改檔案格式。具有這種結構的陣列仍然可以儲存和恢復，並且可以透過使用loadedarray.view(correct_dtype)方法恢復正確的資料型別。

副檔名

我們建議使用.npy和.npz副檔名儲存以這種格式儲存的檔案。這絕不是一個要求；應用程式可能希望使用這些檔案格式，但使用特定於應用程式的副檔名。然而，在沒有明顯替代方案的情況下，我們建議使用.npy和.npz。

版本編號

這些格式的版本編號與 NumPy 版本編號是獨立的。如果格式升級，numpy.io中的程式碼仍然能夠讀取和寫入 Version 1.0 檔案。

格式版本 1.0

前 6 個位元組是一個魔術字串：正好是\x93NUMPY。

接下來的 1 個位元組是一個無符號位元組：檔案格式的主要版本號，例如\x01。

接下來的 1 個位元組是一個無符號位元組：檔案格式的次要版本號，例如\x00。注意：檔案格式的版本與 numpy 軟體包的版本無關。

接下來的 2 個位元組形成一個小端無符號短整數：頭部資料 HEADER_LEN 的長度。

接下來的 HEADER_LEN 位元組形成描述陣列格式的頭部資料。它是一個 ASCII 字串，其中包含一個字典的 Python 文字表示式。它以換行符（\n）結尾，並用空格（\x20）填充，使得len(magic string) + 2 + len(length) + HEADER_LEN的總和能夠被 64 整除，以便對齊。

字典包含三個鍵：

“descr”dtype.descr

可以作為引數傳遞給numpy.dtype建構函式以建立陣列 dtype 的物件。

“fortran_order”bool

陣列資料是否是 Fortran 連續的。由於 Fortran 連續陣列是一種常見的非 C 連續形式，我們允許它們直接寫入磁碟以提高效率。

“shape”int 元組

陣列的形狀。

為了重複性和可讀性，字典鍵按字母順序排序。這僅僅是為了方便。如果可能的話，寫入者應該實現這一點。讀者不應該依賴於此。

在頭部之後是陣列資料。如果 dtype 包含 Python 物件（即dtype.hasobject is True），那麼資料是陣列的 Python pickle。否則，資料是陣列的連續（無論是 C 還是 Fortran，取決於fortran_order）位元組。消費者可以透過將形狀給定的元素數量相乘（注意shape=()表示有 1 個元素）來計算位元組數，乘以dtype.itemsize。

格式版本 2.0

版本 1.0 格式只允許陣列頭部的總大小為 65535 位元組。這可以被具有大量列的結構化陣列超過。版本 2.0 格式將頭部大小擴充套件到 4 GiB。numpy.save將自動儲存為 2.0 格式，如果資料需要，否則它將始終使用更相容的 1.0 格式。

因此，頭部的第四個元素的描述變為：“接下來的 4 個位元組形成一個小端無符號整數：頭部資料 HEADER_LEN 的長度。”

格式版本 3.0

這個版本用 utf8 編碼的字串替換了 ASCII 字串（實際上是 latin1），因此支援具有任何 Unicode 欄位名稱的結構化型別。

注意

.npy 格式，包括建立動機和與其他替代方案的比較，在 “npy-format” NEP 中有描述，然而隨著時間的推移，細節已經發生變化，本文件更為當前。

線性代數（numpy.linalg）

原文：numpy.org/doc/1.26/reference/routines.linalg.html

NumPy 線性代數函式依賴於 BLAS 和 LAPACK，提供了標準線性代數演算法的高效低階實現。這些庫可能由 NumPy 自身提供，使用了它們的參考實現的 C 版本，但是在可能的情況下，更傾向於利用專門處理器功能的高度最佳化庫。這些庫的示例包括OpenBLAS，MKL (TM)和 ATLAS。由於這些庫是多執行緒且處理器相關的，可能需要環境變數和外部包，如threadpoolctl，來控制執行緒數或指定處理器架構。

SciPy 庫還包含一個linalg子模組，SciPy 和 NumPy 子模組提供的功能有重疊。SciPy 包含了在numpy.linalg中找不到的函式，如與 LU 分解和 Schur 分解相關的函式，多種計算偽逆的方法，以及矩陣的函式，如矩陣對數。一些在兩者中都存在的函式在scipy.linalg中具有增強功能。例如，scipy.linalg.eig可以接受第二個矩陣引數來解決廣義特徵值問題。然而，NumPy 中的一些函式具有更靈活的廣播選項。例如，numpy.linalg.solve可以處理“堆疊”陣列，而scipy.linalg.solve只接受單個方陣作為其第一個引數。

注意

在本頁中使用的術語矩陣指的是一個 2d numpy.array物件，而不是一個numpy.matrix物件。後者已不再推薦，即使是用於線性代數。有關更多資訊，請參閱矩陣物件文件。

@運算子

介紹自 NumPy 1.10.0 起，@運算子在計算 2d 陣列之間的矩陣乘積時比其他方法更可取。numpy.matmul函式實現了@運算子。

矩陣和向量乘積

dot(a, b[, out])	兩個陣列的點積。
linalg.multi_dot(arrays, *[, out])	在單個函式呼叫中計算兩個或多個陣列的點積，同時自動選擇最快的計算順序。
vdot(a, b, /)	返回兩個向量的點積。
inner(a, b, /)	兩個陣列的內積。
outer(a, b[, out])	計算兩個向量的外積。
matmul(x1, x2, /[, out, casting, order, ...])	兩個陣列的矩陣乘積。
tensordot(a, b[, axes])	計算沿指定軸的張量點積。
einsum(subscripts, *operands[, out, dtype, ...])	對運算元執行 Einstein 求和約定。
einsum_path(subscripts, *operands[, optimize])	透過考慮中間陣列的建立，評估 einsum 表示式的最低成本收縮順序。
linalg.matrix_power(a, n)	將方陣提升到（整數）冪n。
kron(a, b)	兩個陣列的 Kronecker 積。

分解

linalg.cholesky(a)	Cholesky 分解。
linalg.qr(a[, mode])	計算矩陣的 qr 分解。
linalg.svd(a[, full_matrices, compute_uv, ...])	奇異值分解。

矩陣特徵值

linalg.eig(a)	計算方陣的特徵值和右特徵向量。
linalg.eigh(a[, UPLO])	返回復厄米（共軛對稱）或實對稱矩陣的特徵值和特徵向量。
linalg.eigvals(a)	計算一般矩陣的特徵值。
linalg.eigvalsh(a[, UPLO])	計算復厄米或實對稱矩陣的特徵值。

範數和其他數字

linalg.norm(x[, ord, axis, keepdims])	矩陣或向量範數。
linalg.cond(x[, p])	計算矩陣的條件數。
linalg.det(a)	計算陣列的行列式。
linalg.matrix_rank(A[, tol, hermitian])	使用 SVD 方法返回陣列的矩陣秩
linalg.slogdet(a)	計算陣列行列式的符號和（自然）對數。
trace(a[, offset, axis1, axis2, dtype, out])	返回陣列對角線上的和。

解方程和矩陣求逆

linalg.solve(a, b)	解線性矩陣方程或線性標量方程組。
linalg.tensorsolve(a, b[, axes])	解張量方程 a x = b 以求解 x。
linalg.lstsq(a, b[, rcond])	返回線性矩陣方程的最小二乘解。
linalg.inv(a)	計算矩陣的（乘法）逆。
linalg.pinv(a[, rcond, hermitian])	計算矩陣的（Moore-Penrose）偽逆。
linalg.tensorinv(a[, ind])	計算 N 維陣列的“逆”。

異常

linalg.LinAlgError	由 linalg 函式引發的通用 Python 異常派生物件。

一次對多個矩陣進行線性代數運算

新版本為 1.8.0。

上述列出的幾個線性代數例程能夠同時為多個矩陣計算結果，只要它們堆疊到同一個陣列中。

在文件中透過輸入引數規範來指示，例如 a : (..., M, M) array_like。這意味著，例如給定輸入陣列 a.shape == (N, M, M)，它被解釋為 N 個大小為 M×M 的矩陣的“堆疊”。類似的規範適用於返回值，例如行列式具有 det : (...)，在這種情況下將返回形狀為 det(a).shape == (N,) 的陣列。這推廣到對更高維陣列的線性代數操作：多維陣列的最後 1 或 2 維被解釋為向量或矩陣，適用於每個操作。

@ 運算子

在 NumPy 1.10.0 中引入，@ 運算子在計算二維陣列之間的矩陣乘積時優於其他方法。numpy.matmul 函式實現了 @ 運算子。

矩陣和向量乘積

dot(a, b[, out])	兩個陣列的點積。
linalg.multi_dot(arrays, *[, out])	在單個函式呼叫中計算兩個或多個陣列的點積，同時自動選擇最快的計算順序。
vdot(a, b, /)	返回兩個向量的點積。
inner(a, b, /)	兩個陣列的內積。
outer(a, b[, out])	計算兩個向量的外積。
matmul(x1, x2, /[, out, casting, order, ...])	兩個陣列的矩陣乘積。
tensordot(a, b[, axes])	計算沿指定軸的張量點積。
einsum(subscripts, *operands[, out, dtype, ...])	對運算元執行愛因斯坦求和約定。
einsum_path(subscripts, *operands[, optimize])	透過考慮建立中間陣列來評估 einsum 表示式的最低成本收縮順序。
linalg.matrix_power(a, n)	將方陣提升到（整數）冪 n。
kron(a, b)	兩個陣列的 Kronecker 乘積。

分解

linalg.cholesky(a)	Cholesky 分解。
linalg.qr(a[, mode])	計算矩陣的 QR 分解。
linalg.svd(a[, full_matrices, compute_uv, ...])	奇異值分解。

矩陣特徵值

linalg.eig(a)	計算方陣的特徵值和右特徵向量。
linalg.eigh(a[, UPLO])	返回複共軛厄米特（共軛對稱）或實對稱矩陣的特徵值和特徵向量。
linalg.eigvals(a)	計算一般矩陣的特徵值。
linalg.eigvalsh(a[, UPLO])	計算複共軛厄米特或實對稱矩陣的特徵值。

範數和其他數字

linalg.norm(x[, ord, axis, keepdims])	矩陣或向量範數。
linalg.cond(x[, p])	計算矩陣的條件數。
linalg.det(a)	計算陣列的行列式。
linalg.matrix_rank(A[, tol, hermitian])	使用 SVD 方法返回陣列的矩陣秩
linalg.slogdet(a)	計算陣列行列式的符號和（自然）對數。
trace(a[, offset, axis1, axis2, dtype, out])	返回陣列對角線上��和。

解方程和矩陣求逆

linalg.solve(a, b)	解線性矩陣方程或線性標量方程組。
linalg.tensorsolve(a, b[, axes])	解張量方程 a x = b 得到 x。
linalg.lstsq(a, b[, rcond])	返回線性矩陣方程的最小二乘解。
linalg.inv(a)	計算矩陣的（乘法）逆。
linalg.pinv(a[, rcond, hermitian])	計算矩陣的（Moore-Penrose）偽逆。
linalg.tensorinv(a[, ind])	計算 N 維陣列的“逆”。

異常

linalg.LinAlgError	由 linalg 函式引發的通用 Python 異常派生物件。

一次對多個矩陣進行線性代數運算

新版本為 1.8.0。

上述幾個線性代數例程能夠同時計算多個矩陣的結果，如果它們堆疊到同一個陣列中。

這在文件中透過輸入引數規範來指示，例如 a : (..., M, M) array_like。這意味著，例如給定輸入陣列 a.shape == (N, M, M)，它被解釋為“N 個大小為 M 乘 M 的矩陣”堆疊在一起。類似的規範也適用於返回值，例如行列式具有 det : (...)，在這種情況下將返回形狀為 det(a).shape == (N,) 的陣列。這推廣到對高維陣列進行線性代數運算：多維陣列的最後 1 或 2 維被解釋為向量或矩陣，適用於每個操作。

numpy.dot

原文：numpy.org/doc/1.26/reference/generated/numpy.dot.html

numpy.dot(a, b, out=None)

兩個陣列的點積。具體來說，

• 如果a和b都是 1-D 陣列，則是向量的內積（不進行復共軛）。

• 如果a和b都是 2-D 陣列，則是矩陣乘法，但推薦使用matmul或a @ b。

• 如果a或b中有一個是 0-D（標量），它等同於multiply，推薦使用numpy.multiply(a, b)或a * b。

• 如果a是一個 N 維陣列，b是一個 1-D 陣列，則是a的最後一個軸和b的和積。

• 如果a是一個 N 維陣列，b是一個 M 維陣列（其中M>=2），它是a的最後一個軸和b的倒數第二個軸的和積：

  dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]) 
  

在可能的情況下使用最佳化的 BLAS 庫（參見numpy.linalg）。

引數：

a類似陣列

第一個引數。

b類似陣列

第二個引數。

out陣列，可選

輸出引數。必須具有與未使用時返回的完全相同的型別。特別是，它必須具有正確的型別，必須是 C 連續的，其 dtype 必須是對於dot(a,b)將返回的 dtype。這是一個效能特性。因此，如果不滿足這些條件，將引發異常，而不是嘗試靈活處理。

返回：

output陣列

返回a和b的點積。如果a和b都是標量或都是 1-D 陣列，則返回一個標量；否則返回一個陣列。如果給定out，則返回它。

引發：

ValueError

如果a的最後一個維度與b的倒數第二個維度大小不同。

另請參閱

vdot

複共軛點積。

tensordot

在任意軸上的和積。

einsum

愛因斯坦求和約定。

matmul

‘@’運算子作為帶有輸出引數的方法。

linalg.multi_dot

點積鏈式。

示例

>>> np.dot(3, 4)
12 

兩個引數都不進行復共軛：

>>> np.dot([2j, 3j], [2j, 3j])
(-13+0j) 

對於 2-D 陣列，它是矩陣乘積：

>>> a = [[1, 0], [0, 1]]
>>> b = [[4, 1], [2, 2]]
>>> np.dot(a, b)
array([[4, 1],
 [2, 2]]) 

>>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
>>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
>>> np.dot(a, b)[2,3,2,1,2,2]
499128
>>> sum(a[2,3,2,:] * b[1,2,:,2])
499128 

numpy.linalg.multi_dot

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.multi_dot.html

linalg.multi_dot(arrays, *, out=None)

在單個函式呼叫中計算兩個或多個陣列的點積，同時自動選擇最快的評估順序。

multi_dot連結numpy.dot並使用矩陣的最佳括號化[1] [2]。根據矩陣的形狀，這可以大大加快乘法運算速度。

如果第一個引數是 1-D，則將其視為行向量。如果最後一個引數是 1-D，則將其視為列向量。其他引數必須是 2-D。

將multi_dot視為：

def multi_dot(arrays): return functools.reduce(np.dot, arrays) 

引數：

arrays陣列序列

如果第一個引數是 1-D，則將其視為行向量。如果最後一個引數是 1-D，則將其視為列向量。其他引數必須是 2-D。

outndarray，可選

輸出引數。這必須具有與未使用時返回的完全相同的型別。特別是，它必須具有正確的型別，必須是 C 連續的，其 dtype 必須是dot(a, b)將返回的 dtype。這是一個效能特性。因此，如果不滿足這些條件，將引發異常，而不是嘗試靈活處理。

版本 1.19.0 中的新功能。

返回：

outputndarray

返回所提供陣列的點積。

參見

numpy.dot

兩個引數的點乘。

筆記

可以使用以下函式計算矩陣乘法的成本：

def cost(A, B):
    return A.shape[0] * A.shape[1] * B.shape[1] 

假設我們有三個矩陣 (A_{10x100}, B_{100x5}, C_{5x50})。

兩種不同括號化的成本如下：

cost((AB)C) = 10*100*5 + 10*5*50   = 5000 + 2500   = 7500
cost(A(BC)) = 10*100*50 + 100*5*50 = 50000 + 25000 = 75000 

參考資料

[1]

Cormen，“演算法導論”，第 15.2 章，第 370-378 頁

[2]

en.wikipedia.org/wiki/Matrix_chain_multiplication

示例

multi_dot允許您編寫：

>>> from numpy.linalg import multi_dot
>>> # Prepare some data
>>> A = np.random.random((10000, 100))
>>> B = np.random.random((100, 1000))
>>> C = np.random.random((1000, 5))
>>> D = np.random.random((5, 333))
>>> # the actual dot multiplication
>>> _ = multi_dot([A, B, C, D]) 

而不是：

>>> _ = np.dot(np.dot(np.dot(A, B), C), D)
>>> # or
>>> _ = A.dot(B).dot(C).dot(D) 

numpy.vdot

原文：numpy.org/doc/1.26/reference/generated/numpy.vdot.html

numpy.vdot(a, b, /)

返回兩個向量的點積。

函式 vdot(a, b)處理複數與 dot(a, b)不同。如果第一個引數是複數，則在計算點積時會使用第一個引數的複共軛。

注意，vdot與dot處理多維陣列的方式不同：它不執行矩陣乘積，而是首先將輸入引數展平為 1-D 向量。因此，它只應用於向量。

引數：

aarray_like

如果a是複數，則在計算點積之前會取其複共軛。

barray_like

點積的第二個引數。

返回：

outputndarray

a和b的點積。根據a和b的型別，可以是 int、float 或 complex。

另請參閱

dot

返回點積，不使用第一個引數的複共軛。

示例

>>> a = np.array([1+2j,3+4j])
>>> b = np.array([5+6j,7+8j])
>>> np.vdot(a, b)
(70-8j)
>>> np.vdot(b, a)
(70+8j) 

注意，高維陣列會被展平！

>>> a = np.array([[1, 4], [5, 6]])
>>> b = np.array([[4, 1], [2, 2]])
>>> np.vdot(a, b)
30
>>> np.vdot(b, a)
30
>>> 1*4 + 4*1 + 5*2 + 6*2
30 

numpy.inner

原文：numpy.org/doc/1.26/reference/generated/numpy.inner.html

numpy.inner(a, b, /)

兩個陣列的內積。

向量的普通內積對於 1-D 陣列（不包括複共軛），在更高維度上是最後軸上的求和乘積。

引數：

a, b陣列樣式

如果a和b都是非標量，則它們的最後維必須匹配。

返回：

out ndarray

如果a和b都是標量或者都是 1-D 陣列，則返回一個標量；否則返回一個陣列。out.shape = (*a.shape[:-1], *b.shape[:-1])

引發：

ValueError

如果a和b都是非標量且它們的最後維大小不同。

另請參閱

tensordot

在任意軸上求和乘積。

dot

廣義矩陣乘積，使用b的倒數第二維。

einsum

愛因斯坦求和約定。

注意

對於向量（1-D 陣列），它計算普通內積：

np.inner(a, b) = sum(a[:]*b[:]) 

更一般地，如果ndim(a) = r > 0且ndim(b) = s > 0：

np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1)) 

或者明確地：

np.inner(a, b)[i0,...,ir-2,j0,...,js-2]
     = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:]) 

此外，a或b可能是標量，此時：

np.inner(a,b) = a*b 

示例

向量的普通內積：

>>> a = np.array([1,2,3])
>>> b = np.array([0,1,0])
>>> np.inner(a, b)
2 

一些多維示例：

>>> a = np.arange(24).reshape((2,3,4))
>>> b = np.arange(4)
>>> c = np.inner(a, b)
>>> c.shape
(2, 3)
>>> c
array([[ 14,  38,  62],
 [ 86, 110, 134]]) 

>>> a = np.arange(2).reshape((1,1,2))
>>> b = np.arange(6).reshape((3,2))
>>> c = np.inner(a, b)
>>> c.shape
(1, 1, 3)
>>> c
array([[[1, 3, 5]]]) 

b是標量的一個示例：

>>> np.inner(np.eye(2), 7)
array([[7., 0.],
 [0., 7.]]) 

numpy.outer

原文：numpy.org/doc/1.26/reference/generated/numpy.outer.html

numpy.outer(a, b, out=None)

計算兩個向量的外積。

給定長度分別為M和N的兩個向量a和b，外積[1]為：

[[a_0*b_0  a_0*b_1 ... a_0*b_{N-1} ]
 [a_1*b_0    .
 [ ...          .
 [a_{M-1}*b_0            a_{M-1}*b_{N-1} ]] 

引數：

a(M,) array_like

第一個輸入向量。如果不是 1 維的，則會被展平。

b(N,) array_like

第二個輸入向量。如果不是 1 維的，則會被展平。

out(M, N) ndarray, optional

結果儲存的位置

1.9.0 版本中的新功能。

返回：

out(M, N) ndarray

out[i, j] = a[i] * b[j]

另請參閱

inner

einsum

einsum('i,j->ij', a.ravel(), b.ravel())是等效的。

ufunc.outer

除了 1D 維度和其他操作外，還有其他維度的泛化。np.multiply.outer(a.ravel(), b.ravel())是等效的。

tensordot

np.tensordot(a.ravel(), b.ravel(), axes=((), ()))是等效的。

參考

[1]

G. H. Golub 和 C. F. Van Loan，《矩陣計算》，第 3 版，馬里蘭州巴爾的摩，約翰斯·霍普金斯大學出版社，1996 年，第 8 頁。

示例

建立一個（非常）粗糙的網格以計算 Mandelbrot 集：

>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
>>> rl
array([[-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.]])
>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
>>> im
array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
 [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
 [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
 [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
 [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
>>> grid = rl + im
>>> grid
array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
 [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
 [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
 [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
 [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]]) 

一個使用字母“向量”的示例：

>>> x = np.array(['a', 'b', 'c'], dtype=object)
>>> np.outer(x, [1, 2, 3])
array([['a', 'aa', 'aaa'],
 ['b', 'bb', 'bbb'],
 ['c', 'cc', 'ccc']], dtype=object) 

numpy.matmul

原文：numpy.org/doc/1.26/reference/generated/numpy.matmul.html

numpy.matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) = <ufunc 'matmul'>

兩個陣列的矩陣乘積。

引數：

x1, x2array_like

輸入陣列，不允許標量。

outndarray，可選

儲存結果的位置。如果提供，它必須具有與簽名 (n,k),(k,m)->(n,m) 匹配的形狀。如果未提供或為 None，則返回一個新分配的陣列。

**kwargs

對於其他僅關鍵字引數，請參閱 ufunc 文件。

版本 1.16 中的新功能：現在處理 ufunc kwargs

返回：

yndarray

輸入的矩陣乘積。僅當 x1、x2 都是 1-D 向量時才是標量。

引發：

ValueError

如果x1的最後一個維度與x2的倒數第二個維度大小不同。

如果傳入了一個標量值。

另請參見

vdot

複共軛點積。

tensordot

在任意軸上求和乘積。

einsum

愛因斯坦求和約定。

dot

具有不同廣播規則的替代矩陣乘積。

注意

行為取決於以下方式的引數。

• 如果兩個引數都是 2-D，則它們將像常規矩陣一樣相乘。

• 如果任一引數是 N-D，N > 2，則將其視為駐留在最後兩個索引中的矩陣堆疊，並相應地進行廣播。

• 如果第一個引數是 1-D，則透過在其維度前新增 1 來將其提升為矩陣。矩陣乘法後，前置的 1 將被移除。

• 如果第二個引數是 1-D，則透過在其維度後新增 1 來將其提升為矩陣。矩陣乘法後，附加的 1 將被移除。

matmul 與 dot 在兩個重要方面有所不同：

• 標量乘法不允許，使用*代替。

• 矩陣堆疊將一起廣播，就好像矩陣是元素一樣，遵守簽名(n,k),(k,m)->(n,m)：

  >>> a = np.ones([9, 5, 7, 4])
  >>> c = np.ones([9, 5, 4, 3])
  >>> np.dot(a, c).shape
  (9, 5, 7, 9, 5, 3)
  >>> np.matmul(a, c).shape
  (9, 5, 7, 3)
  >>> # n is 7, k is 4, m is 3 
  

matmul 函式實現了 Python 3.5 中引入的@運算子的語義，遵循PEP 465。

在可能的情況下使用最佳化的 BLAS 庫（請參閱numpy.linalg）。

示例

對於 2-D 陣列，它是矩陣乘積：

>>> a = np.array([[1, 0],
...               [0, 1]])
>>> b = np.array([[4, 1],
...               [2, 2]])
>>> np.matmul(a, b)
array([[4, 1],
 [2, 2]]) 

對於 2-D 與 1-D 混合，結果是通常的。

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

對於陣列堆疊，廣播是常規的

>>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
>>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
>>> np.matmul(a,b).shape
(2, 2, 2)
>>> np.matmul(a, b)[0, 1, 1]
98
>>> sum(a[0, 1, :] * b[0 , :, 1])
98 

向量、向量返回標量內積，但兩個引數都不是複共軛的：

>>> np.matmul([2j, 3j], [2j, 3j])
(-13+0j) 

標量乘法會引發錯誤。

>>> np.matmul([1,2], 3)
Traceback (most recent call last):
...
ValueError: matmul: Input operand 1 does not have enough dimensions ... 

@運算子可用作 ndarrays 上np.matmul的簡寫。

>>> x1 = np.array([2j, 3j])
>>> x2 = np.array([2j, 3j])
>>> x1 @ x2
(-13+0j) 

版本 1.10.0 中的新功能。

numpy.tensordot

原文：numpy.org/doc/1.26/reference/generated/numpy.tensordot.html

numpy.tensordot(a, b, axes=2)

沿指定軸計算張量點積。

給定兩個張量a和b，以及包含兩個 array_like 物件（(a_axes, b_axes)）的 array_like 物件，對a和b的元素（分量）在由a_axes和b_axes指定的軸上的乘積求和。第三個引數可以是一個單個非負整數型標量N；如果是這樣，那麼a的最後N個維度和b的前N個維度將被求和。

引數：

a, b array_like

要“點積”的張量。

axes int 或 (2,) array_like

• integer_like 如果是一個 int N，則按順序對a的最後 N 個軸和b的前 N 個軸求和。相應軸的大小必須匹配。

• (2,) array_like 或者，一個要進行求和的軸的列表，第一個序列應用於a，第二個序列應用於b。這兩個元素的 array_like 必須具有相同的長度。

返回：

output ndarray

輸入的張量點積。

另請參閱

dot, einsum

注意

三種常見用例是：

• axes = 0：張量積(a\otimes b)

• axes = 1：張量點積(a\cdot b)

• axes = 2：（預設）張量雙縮並(a:b)

當axes是整數型時，求和的順序將是：首先是a中的第-N 個軸和b中的第 0 個軸，然後是a中的第-1 個軸和b中的第 N 個軸。

當有多個要求和的軸 - 並且它們不是a（b）的最後（第一個）軸時 - 引數axes應該由兩個相同長度的序列組成，第一個要求和的軸首先在兩個序列中給出，第二個軸第二個，依此類推。

結果的形狀由第一個張量的未縮並軸，後跟第二個張量的未縮並軸組成。

示例

一個“傳統”的示例：

>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
>>> c.shape
(5, 2)
>>> c
array([[4400., 4730.],
 [4532., 4874.],
 [4664., 5018.],
 [4796., 5162.],
 [4928., 5306.]])
>>> # A slower but equivalent way of computing the same...
>>> d = np.zeros((5,2))
>>> for i in range(5):
...   for j in range(2):
...     for k in range(3):
...       for n in range(4):
...         d[i,j] += a[k,n,i] * b[n,k,j]
>>> c == d
array([[ True,  True],
 [ True,  True],
 [ True,  True],
 [ True,  True],
 [ True,  True]]) 

利用+和*的過載的擴充套件示例：

>>> a = np.array(range(1, 9))
>>> a.shape = (2, 2, 2)
>>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
>>> A.shape = (2, 2)
>>> a; A
array([[[1, 2],
 [3, 4]],
 [[5, 6],
 [7, 8]]])
array([['a', 'b'],
 ['c', 'd']], dtype=object) 

>>> np.tensordot(a, A) # third argument default is 2 for double-contraction
array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object) 

>>> np.tensordot(a, A, 1)
array([[['acc', 'bdd'],
 ['aaacccc', 'bbbdddd']],
 [['aaaaacccccc', 'bbbbbdddddd'],
 ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object) 

>>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
array([[[[['a', 'b'],
 ['c', 'd']],
 ... 

>>> np.tensordot(a, A, (0, 1))
array([[['abbbbb', 'cddddd'],
 ['aabbbbbb', 'ccdddddd']],
 [['aaabbbbbbb', 'cccddddddd'],
 ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object) 

>>> np.tensordot(a, A, (2, 1))
array([[['abb', 'cdd'],
 ['aaabbbb', 'cccdddd']],
 [['aaaaabbbbbb', 'cccccdddddd'],
 ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object) 

>>> np.tensordot(a, A, ((0, 1), (0, 1)))
array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object) 

>>> np.tensordot(a, A, ((2, 1), (1, 0)))
array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object) 

numpy.einsum

原文：numpy.org/doc/1.26/reference/generated/numpy.einsum.html

numpy.einsum(subscripts, *operands, out=None, dtype=None, order='K', casting='safe', optimize=False)

對運算元執行愛因斯坦求和約定的計算。

使用愛因斯坦求和約定，許多常見的多維線性代數陣列操作可以以簡單的方式表示。在隱式模式下，einsum計算這些值。

在顯式模式下，einsum提供了進一步的靈活性，以計算可能不被視為經典愛因斯坦求和操作的其他陣列操作，透過禁用或強制對指定的下標標籤進行求和。

請參閱說明和示例以進行澄清。

引數：

下標str

指定求和的下標為逗號分隔的下標標籤列表。除非包括明確的指示符‘->’以及精確輸出形式的下標標籤，否則將執行隱式（經典愛因斯坦求和）計算。

運算元陣列列表

這些是操作的陣列。

輸出ndarray，可選

如果提供，計算將在此陣列中進行。

dtype，可選

如果提供，強制計算使用指定的資料型別。請注意，您可能還需要提供一個更自由的轉換引數以允許轉換。預設值為 None。

順序，可選

控制輸出的記憶體佈局。‘C’表示它應該是 C 連續的。‘F’表示它應該是 Fortran 連續的，‘A’表示如果輸入都是‘F’，則應該是‘F’，否則為‘C’。‘K’表示應儘可能接近輸入的佈局，包括任意排列的軸。預設值為‘K’。

casting，可選

控制可能發生的資料轉換型別。不建議將其設定為‘unsafe’，因為它可能會對累積產生不利影響。

• ‘no’表示資料型別不應被轉換。
• ‘equiv’表示僅允許位元組順序更改。
• ‘safe’表示僅允許可以保留值的轉換。
• ‘same_kind’表示僅允許安全轉換或在一種型別內的轉換，例如從 float64 到 float32。
• ‘unsafe’表示可能進行任何資料轉換。

預設值為‘safe’。

最佳化，可選

控制是否應進行中間最佳化。如果為 False，則不會進行任何最佳化，如果為 True，則預設為‘greedy’演算法。還接受來自np.einsum_path函式的顯式收縮列表。有關更多詳細資訊，請參見np.einsum_path。預設為 False。

返回：

輸出ndarray

基於愛因斯坦求和約定的計算。

參見

einsum_path, dot, inner, outer, tensordot, linalg.multi_dot

einops

類似的冗長介面由einops包提供，以涵蓋額外的操作：轉置，重塑/展平，重複/平鋪，擠壓/展開和約簡。

opt_einsum

opt_einsum以與後端無關的方式最佳化了類似 einsum 表示式的收縮順序。

注意事項

版本 1.6.0 中的新功能。

愛因斯坦求和約定可用於計算許多多維、線性代數的陣列操作。einsum提供了一種簡潔的表示方式。

以下是einsum可以計算的一些操作的非窮盡列表，以及示例：

• 陣列的跡，numpy.trace.

• 返回對角線，numpy.diag。

• 陣列軸求和，numpy.sum。

• 轉置和排列，numpy.transpose.

• 矩陣乘法和點積，numpy.matmul numpy.dot。

• 向量內積和外積，numpy.inner numpy.outer。

• 廣播，逐元素和標量乘法，numpy.multiply。

• 張量收縮，numpy.tensordot.

• 鏈式陣列操作，按照高效的計算順序，numpy.einsum_path。

下標字串是一個逗號分隔的下標標籤列表，其中每個標籤指的是相應運算元的一個維度。每當一個標籤重複出現時，它就會被求和，因此np.einsum('i,i', a, b)等同於np.inner(a,b)。如果一個標籤只出現一次，它就不會被求和，因此np.einsum('i', a)會產生一個不變的a檢視。進一步的例子np.einsum('ij,jk', a, b)描述了傳統的矩陣乘法，並等同於np.matmul(a,b)。一個運算元中重複的下標標籤會取對角線。例如，np.einsum('ii', a)等同於np.trace(a)。

在隱式模式下，所選擇的下標很重要，因為輸出的軸會按字母順序重新排序。這意味著np.einsum('ij', a)不會影響 2D 陣列，而np.einsum('ji', a)會取其轉置。此外，np.einsum('ij,jk', a, b)返回矩陣乘法，而np.einsum('ij,jh', a, b)返回乘法的轉置，因為下標‘h’在下標‘i’之前。

在顯式模式下，輸出可以透過指定輸出下標標籤來直接控制。這需要識別符號‘->’以及輸出下標標籤列表。此功能增加了函式的靈活性，因為可以在需要時禁用或強制求和。呼叫np.einsum('i->', a)類似於np.sum(a, axis=-1)，而np.einsum('ii->i', a)類似於np.diag(a)。不同之處在於einsum預設不允許廣播。此外，np.einsum('ij,jh->ih', a, b)直接指定了輸出下標標籤的順序，因此返回矩陣乘法，不同於上面隱式模式中的示例。

要啟用和控制廣播，請使用省略號。預設的 NumPy 風格廣播是透過在每個術語的左側新增省略號來完成的，例如np.einsum('...ii->...i', a)。要沿著第一個和最後一個軸進行跡運算，可以使用np.einsum('i...i', a)，或者要使用左側索引進行矩陣-矩陣乘法而不是右側索引，可以使用np.einsum('ij...,jk...->ik...', a, b)。

當只有一個運算元時，不會對軸求和，並且沒有提供輸出引數，則會返回對運算元的檢視，而不是新陣列。因此，對角線作為np.einsum('ii->i', a)會產生一個檢視（在版本 1.10.0 中更改）。

einsum還提供了另一種提供下標和運算元的方法，即einsum(op0, sublist0, op1, sublist1, ..., [sublistout])。如果沒有以這種格式提供輸出形狀，則將以隱式模式計算einsum，否則將以顯式模式執行。下面的示例具有相應的einsum呼叫，使用了兩個引數方法。

版本 1.10.0 中的新功能。

從 einsum 返回的檢視現在在輸入陣列可寫時也是可寫的。例如，np.einsum('ijk...->kji...', a)現在將產生與np.swapaxes(a, 0, 2)相同的效果，而np.einsum('ii->i', a)將返回 2D 陣列對角線的可寫檢視。

版本 1.12.0 中的新功能。

新增了optimize引數，它將最佳化 einsum 表示式的收縮順序。對於三個或更多運算元的收縮，這可以大大增加計算效率，但在計算過程中會增加更大的記憶體佔用。

通常應用‘貪婪’演算法，經驗測試表明在大多數情況下返回最優路徑。在某些情況下，‘最優’將透過更昂貴的、詳盡的搜尋返回超級路徑。對於迭代計算，建議計算一次最優路徑並透過將其作為引數提供來重複使用該路徑。下面給出一個示例。

檢視numpy.einsum_path以獲取更多詳細資訊。

示例

>>> a = np.arange(25).reshape(5,5)
>>> b = np.arange(5)
>>> c = np.arange(6).reshape(2,3) 

矩陣的跡：

>>> np.einsum('ii', a)
60
>>> np.einsum(a, [0,0])
60
>>> np.trace(a)
60 

提取對角線（需要顯式形式）：

>>> np.einsum('ii->i', a)
array([ 0,  6, 12, 18, 24])
>>> np.einsum(a, [0,0], [0])
array([ 0,  6, 12, 18, 24])
>>> np.diag(a)
array([ 0,  6, 12, 18, 24]) 

沿軸求和（需要顯式形式）：

>>> np.einsum('ij->i', a)
array([ 10,  35,  60,  85, 110])
>>> np.einsum(a, [0,1], [0])
array([ 10,  35,  60,  85, 110])
>>> np.sum(a, axis=1)
array([ 10,  35,  60,  85, 110]) 

對於更高維度的陣列，可以使用省略號對單個軸求和：

>>> np.einsum('...j->...', a)
array([ 10,  35,  60,  85, 110])
>>> np.einsum(a, [Ellipsis,1], [Ellipsis])
array([ 10,  35,  60,  85, 110]) 

計算矩陣轉置，或重新排列任意數量的軸：

>>> np.einsum('ji', c)
array([[0, 3],
 [1, 4],
 [2, 5]])
>>> np.einsum('ij->ji', c)
array([[0, 3],
 [1, 4],
 [2, 5]])
>>> np.einsum(c, [1,0])
array([[0, 3],
 [1, 4],
 [2, 5]])
>>> np.transpose(c)
array([[0, 3],
 [1, 4],
 [2, 5]]) 

向量內積：

>>> np.einsum('i,i', b, b)
30
>>> np.einsum(b, [0], b, [0])
30
>>> np.inner(b,b)
30 

矩陣向量乘法：

>>> np.einsum('ij,j', a, b)
array([ 30,  80, 130, 180, 230])
>>> np.einsum(a, [0,1], b, [1])
array([ 30,  80, 130, 180, 230])
>>> np.dot(a, b)
array([ 30,  80, 130, 180, 230])
>>> np.einsum('...j,j', a, b)
array([ 30,  80, 130, 180, 230]) 

廣播和標量乘法：

>>> np.einsum('..., ...', 3, c)
array([[ 0,  3,  6],
 [ 9, 12, 15]])
>>> np.einsum(',ij', 3, c)
array([[ 0,  3,  6],
 [ 9, 12, 15]])
>>> np.einsum(3, [Ellipsis], c, [Ellipsis])
array([[ 0,  3,  6],
 [ 9, 12, 15]])
>>> np.multiply(3, c)
array([[ 0,  3,  6],
 [ 9, 12, 15]]) 

向量外積：

>>> np.einsum('i,j', np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
 [0, 2, 4, 6, 8]])
>>> np.einsum(np.arange(2)+1, [0], b, [1])
array([[0, 1, 2, 3, 4],
 [0, 2, 4, 6, 8]])
>>> np.outer(np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
 [0, 2, 4, 6, 8]]) 

張量收縮：

>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> np.einsum('ijk,jil->kl', a, b)
array([[4400., 4730.],
 [4532., 4874.],
 [4664., 5018.],
 [4796., 5162.],
 [4928., 5306.]])
>>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
array([[4400., 4730.],
 [4532., 4874.],
 [4664., 5018.],
 [4796., 5162.],
 [4928., 5306.]])
>>> np.tensordot(a,b, axes=([1,0],[0,1]))
array([[4400., 4730.],
 [4532., 4874.],
 [4664., 5018.],
 [4796., 5162.],
 [4928., 5306.]]) 

可寫返回陣列（自版本 1.10.0 起）：

>>> a = np.zeros((3, 3))
>>> np.einsum('ii->i', a)[:] = 1
>>> a
array([[1., 0., 0.],
 [0., 1., 0.],
 [0., 0., 1.]]) 

省略號用法示例：

>>> a = np.arange(6).reshape((3,2))
>>> b = np.arange(12).reshape((4,3))
>>> np.einsum('ki,jk->ij', a, b)
array([[10, 28, 46, 64],
 [13, 40, 67, 94]])
>>> np.einsum('ki,...k->i...', a, b)
array([[10, 28, 46, 64],
 [13, 40, 67, 94]])
>>> np.einsum('k...,jk', a, b)
array([[10, 28, 46, 64],
 [13, 40, 67, 94]]) 

鏈式陣列操作。對於更復雜的收縮，透過重複計算‘貪婪’路徑或預先計算‘最優’路徑並重復應用它，使用einsum_path插入（自版本 1.12.0 起）可能實現速度提升。效能改進在處理更大的陣列時可能特別顯著：

>>> a = np.ones(64).reshape(2,4,8) 

基本的einsum：~1520ms（在 3.1GHz 英特爾 i5 上進行基準測試。）

>>> for iteration in range(500):
...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a) 

子最佳化的einsum（由於重複路徑計算時間）：~330ms

>>> for iteration in range(500):
...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal') 

貪婪的einsum（更快的最優路徑近似）：~160ms

>>> for iteration in range(500):
...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy') 

最優的einsum（在某些用例中的最佳使用模式）：~110ms

>>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0]
>>> for iteration in range(500):
...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path) 

numpy.einsum_path

原文：numpy.org/doc/1.26/reference/generated/numpy.einsum_path.html

numpy.einsum_path(subscripts, *operands, optimize='greedy')

透過考慮中間陣列的建立，評估einsum表示式的最低成本收縮順序。

引數：

subscripts字串

指定求和的下標。

*operands陣列列表

這些是操作的陣列。

optimize

選擇路徑型別。如果提供了一個元組，則假定第二個引數是建立的最大中間大小。如果只提供了一個引數，則使用最大輸入或輸出陣列大小作為最大中間大小。

• 如果給定以einsum_path開頭的列表，則將其用作收縮路徑

• 如果為 False，則不進行最佳化

• 如果為 True，預設為‘貪婪’演算法

• ‘最佳’ 一種演算法，透過組合地探索列出的張量的所有可能的收縮方式，並選擇成本最低的路徑。隨著收縮項數量的增加呈指數級增長。

• ‘貪婪’ 一種演算法，每一步選擇最佳的對收縮。實際上，該演算法在每一步搜尋最大的內部、Hadamard，然後外部乘積。隨著收縮項數量的增加呈立方比例增長。對於大多數收縮來說，等同於‘最佳’路徑。

預設為‘貪婪’。

返回：

path元組列表

一個einsum路徑的列表表示。

string_repr字串

einsum路徑的可列印表示。

另請參閱

einsum, linalg.multi_dot

注意

結果路徑指示應首先收縮輸入收縮的哪些項，然後將此收縮的結果附加到收縮列表的末尾。然後可以對此列表進行迭代，直到所有中間收縮完成。

示例

我們可以從一個鏈點示例開始。在這種情況下，最佳的做法是首先收縮b和c張量，如路徑的第一個元素(1, 2)所示。結果張量新增到收縮的末尾，然後完成剩餘的收縮(0, 1)。

>>> np.random.seed(123)
>>> a = np.random.rand(2, 2)
>>> b = np.random.rand(2, 5)
>>> c = np.random.rand(5, 2)
>>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
>>> print(path_info[0])
['einsum_path', (1, 2), (0, 1)]
>>> print(path_info[1])
 Complete contraction:  ij,jk,kl->il # may vary
 Naive scaling:  4
 Optimized scaling:  3
 Naive FLOP count:  1.600e+02
 Optimized FLOP count:  5.600e+01
 Theoretical speedup:  2.857
 Largest intermediate:  4.000e+00 elements
-------------------------------------------------------------------------
scaling                  current                                remaining
-------------------------------------------------------------------------
 3                   kl,jk->jl                                ij,jl->il
 3                   jl,ij->il                                   il->il 

一個更復雜的索引轉換示例。

>>> I = np.random.rand(10, 10, 10, 10)
>>> C = np.random.rand(10, 10)
>>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
...                            optimize='greedy') 

>>> print(path_info[0])
['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
>>> print(path_info[1]) 
 Complete contraction:  ea,fb,abcd,gc,hd->efgh # may vary
 Naive scaling:  8
 Optimized scaling:  5
 Naive FLOP count:  8.000e+08
 Optimized FLOP count:  8.000e+05
 Theoretical speedup:  1000.000
 Largest intermediate:  1.000e+04 elements
--------------------------------------------------------------------------
scaling                  current                                remaining
--------------------------------------------------------------------------
 5               abcd,ea->bcde                      fb,gc,hd,bcde->efgh
 5               bcde,fb->cdef                         gc,hd,cdef->efgh
 5               cdef,gc->defg                            hd,defg->efgh
 5               defg,hd->efgh                               efgh->efgh 

numpy.linalg.matrix_power

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.matrix_power.html

linalg.matrix_power(a, n)

將方陣提升到（整數）冪n。

對於正整數n，冪是透過重複矩陣平方和矩陣乘法計算的。如果n == 0，則返回與M相同形狀的單位矩陣。如果n < 0，則計算逆矩陣，然後將其提升到abs(n)次冪。

注意

目前不支援物件矩陣的堆疊。

引數：

a(…, M, M) 類似陣列

要“提升”的矩陣。

n整數

指數可以是任何整數或長整數，正數、負數或零。

返回：

an**(…, M, M) ndarray 或矩陣物件

返回值與M具有相同的形狀和型別；如果指數是正數或零，則元素的型別與M的元素相同。如果指數為負數，則元素為浮點數。

引發：

線性代數錯誤

對於不是方陣的矩陣，或者（對於負冪）無法透過數值方法求逆的情況。

示例

>>> from numpy.linalg import matrix_power
>>> i = np.array([[0, 1], [-1, 0]]) # matrix equiv. of the imaginary unit
>>> matrix_power(i, 3) # should = -i
array([[ 0, -1],
 [ 1,  0]])
>>> matrix_power(i, 0)
array([[1, 0],
 [0, 1]])
>>> matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements
array([[ 0.,  1.],
 [-1.,  0.]]) 

稍微複雜一點的例子

>>> q = np.zeros((4, 4))
>>> q[0:2, 0:2] = -i
>>> q[2:4, 2:4] = i
>>> q # one of the three quaternion units not equal to 1
array([[ 0., -1.,  0.,  0.],
 [ 1.,  0.,  0.,  0.],
 [ 0.,  0.,  0.,  1.],
 [ 0.,  0., -1.,  0.]])
>>> matrix_power(q, 2) # = -np.eye(4)
array([[-1.,  0.,  0.,  0.],
 [ 0., -1.,  0.,  0.],
 [ 0.,  0., -1.,  0.],
 [ 0.,  0.,  0., -1.]]) 

numpy.kron

原文：numpy.org/doc/1.26/reference/generated/numpy.kron.html

numpy.kron(a, b)

兩個陣列的克羅內克積。

計算克羅內克積，由第二個陣列的塊組成，由第一個陣列縮放。

引數：

a, barray_like

返回：

outndarray

另見

outer

外積

注意事項

該函式假定 a 和 b 的維數相同，如有必要，將最小的維數前置為 1。 如果 a.shape = (r0,r1,..,rN) 和 b.shape = (s0,s1,...,sN)，克羅內克積的形狀為 (r0*s0, r1*s1, ..., rN*SN)。 元素是來自 a 和 b 的元素的乘積，透過以下明確組織：

kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN] 

其中：

kt = it * st + jt,  t = 0,...,N 

在常見的二維情況下（N=1），可以視覺化塊結構：

[[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
 [  ...                              ...   ],
 [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]] 

示例

>>> np.kron([1,10,100], [5,6,7])
array([  5,   6,   7, ..., 500, 600, 700])
>>> np.kron([5,6,7], [1,10,100])
array([  5,  50, 500, ...,   7,  70, 700]) 

>>> np.kron(np.eye(2), np.ones((2,2)))
array([[1.,  1.,  0.,  0.],
 [1.,  1.,  0.,  0.],
 [0.,  0.,  1.,  1.],
 [0.,  0.,  1.,  1.]]) 

>>> a = np.arange(100).reshape((2,5,2,5))
>>> b = np.arange(24).reshape((2,3,4))
>>> c = np.kron(a,b)
>>> c.shape
(2, 10, 6, 20)
>>> I = (1,3,0,2)
>>> J = (0,2,1)
>>> J1 = (0,) + J             # extend to ndim=4
>>> S1 = (1,) + b.shape
>>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
>>> c[K] == a[I]*b[J]
True 

numpy.linalg.cholesky

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.cholesky.html

linalg.cholesky(a)

Cholesky 分解。

返回方陣a的 Cholesky 分解， L * L.H，其中L為下三角矩陣，.H 為共軛轉置運算元（如果a是實數值，則為普通轉置）。a必須是埃爾米特（實數值的話就是對稱）並且正定的。沒有檢查是否a是埃爾米特的。此外，只使用a的下三角和對角元素。事實上只返回L。

Parameters:

a(…, M, M) 陣列形式

埃爾米特（如果所有元素都是實數，則為對稱），正定輸入矩陣。

Returns:

L(…, M, M) 陣列形式

a的下三角 Cholesky 分解。如果a是矩陣物件，就返回一個矩陣物件。

Raises:

LinAlgError

若分解失敗，例如a非正定。

See also

scipy.linalg.cholesky

SciPy 中的相似函式。

scipy.linalg.cholesky_banded

對帶狀埃爾米特正定矩陣進行 Cholesky 分解。

scipy.linalg.cho_factor

矩陣的 Cholesky 分解，可用於scipy.linalg.cho_solve中。

Notes

版本 1.8.0 中的新功能。

適用廣播規則，請參見numpy.linalg文件以獲取詳細資訊。

Cholesky 分解通常用作快速求解

[A \mathbf{x} = \mathbf{b}]

（當A既是埃爾米特/對稱且是正定的時候）。

首先，我們求解(\mathbf{y})在

[L \mathbf{y} = \mathbf{b},]

之後，對於(\mathbf{x})，使用

[L.H \mathbf{x} = \mathbf{y}.]

Examples

>>> A = np.array([[1,-2j],[2j,5]])
>>> A
array([[ 1.+0.j, -0.-2.j],
 [ 0.+2.j,  5.+0.j]])
>>> L = np.linalg.cholesky(A)
>>> L
array([[1.+0.j, 0.+0.j],
 [0.+2.j, 1.+0.j]])
>>> np.dot(L, L.T.conj()) # verify that L * L.H = A
array([[1.+0.j, 0.-2.j],
 [0.+2.j, 5.+0.j]])
>>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like?
>>> np.linalg.cholesky(A) # an ndarray object is returned
array([[1.+0.j, 0.+0.j],
 [0.+2.j, 1.+0.j]])
>>> # But a matrix object is returned if A is a matrix object
>>> np.linalg.cholesky(np.matrix(A))
matrix([[ 1.+0.j,  0.+0.j],
 [ 0.+2.j,  1.+0.j]]) 

numpy.linalg.qr

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.qr.html

linalg.qr(a, mode='reduced')

計算矩陣的 qr 分解。

將矩陣a因子化為qr，其中q為正交矩陣，r為上三角矩陣。

引數：

aarray_like，形狀（…，M，N）

至少為 2 的維度的類似陣列物件。

mode，optional

如果 K = min(M，N)，則

• ‘reduced’：返回維度為（…，M，K），（…，K，N）的 Q，R（預設）

• ‘complete’：返回維度為（…，M，M），（…，M，N）的 Q，R

• ‘r’：僅返回維度為（…，K，N）的 R

• ‘raw’：返回維度為（…，N，M），（…，K，）的 h，tau

選項‘reduced’，‘complete’和‘raw’是 numpy 1.8 中的新特性，請查閱說明以獲取更多資訊。預設為‘reduced’，為了與之前版本的 numpy 保持向後相容性，可以省略‘reduced’和舊預設值‘full’。請注意，在‘raw’模式下返回的陣列 h 進行了轉置以呼叫 Fortran。‘economic’模式已棄用。模式‘full’和‘economic’可以僅使用第一個字母進行傳遞以實現向後相容性，但所有其他模式必須拼寫完整。有關更多解釋，請檢視說明。

返回：

當模式為‘reduced’或‘complete’時，結果將是一個具有

屬性Q和R。

Qndarray of float or complex, optional

具有正交列的矩陣。當 mode = ‘complete’時，結果是一個正交/酉矩陣，取決於a是實數還是複數。在這種情況下，行列式可能是+/- 1。如果輸入陣列的維數大於 2，則返回具有上述屬性的矩陣堆疊。

Rndarray of float or complex, optional

上三角矩陣或者如果輸入陣列的維數大於 2，則返回上三角矩陣的堆疊。

(h, tau)ndarrays of np.double or np.cdouble, optional

陣列 h 包含生成 q 和 r 的 Householder 反射器。tau 陣列包含反射器的縮放因子。在不推薦使用的“經濟”模式中，僅返回 h。

引發：

LinAlgError

如果因子化失敗。

另請參閱

scipy.linalg.qr

SciPy 中類似的函式。

scipy.linalg.rq

計算矩陣的 RQ 分解。

說明

這是對 LAPACK 例程dgeqrf，zgeqrf，dorgqr和zungqr的介面。

更多關於 qr 分解的資訊，請參見：[zh.wikipedia.org/wiki/QR 分解](https://zh.wikipedia.org/wiki/QR 分解)

ndarray 下的子類除了 'raw' 模式之外都會被保留。因此，如果 a 的型別是 matrix，那麼所有的返回值也將是矩陣。

NumPy 1.8.0 中新增了 “reduced”，“complete” 和 “raw” 選項以及將 “full” 選項作為 “reduced” 的別名。此外，還棄用了 “full” 和 “economic” 選項。因為 “full” 是先前的預設選項，而 “reduced” 是新的預設選項，所以透過預設設定 mode 即可保持向後相容性。新增 “raw” 選項是為了使用 Householder reflectors 可以將陣列乘以 q 的 LAPACK 函式。請注意，在這種情況下，返回的陣列的型別為 np.double 或 np.cdouble，並且 h 陣列被轉置以符合 FORTRAN 的相容性。目前，numpy 沒有暴露使用 “raw” 返回值的例程，但是一些例程在 lapack_lite 中可用並等待相應的工作。

例子

>>> a = np.random.randn(9, 6)
>>> Q, R = np.linalg.qr(a)
>>> np.allclose(a, np.dot(Q, R))  # a does equal QR
True
>>> R2 = np.linalg.qr(a, mode='r')
>>> np.allclose(R, R2)  # mode='r' returns the same R as mode='full'
True
>>> a = np.random.normal(size=(3, 2, 2)) # Stack of 2 x 2 matrices as input
>>> Q, R = np.linalg.qr(a)
>>> Q.shape
(3, 2, 2)
>>> R.shape
(3, 2, 2)
>>> np.allclose(a, np.matmul(Q, R))
True 

示例說明了 qr 的常見用法：解決最小二乘問題

對於給定資料：{(0,1), (1,0), (1,2), (2,1)}，在 y = y0 + mx 中最小平方最佳的 m 和 y0 是多少？（畫出這些點，你會發現應該是 y0 = 0，m = 1）。這個問題透過解方程組 Ax = b 來得到答案，其中：

A = array([[0, 1], [1, 1], [1, 1], [2, 1]])
x = array([[y0], [m]])
b = array([[1], [0], [2], [1]]) 

如果 A = QR，並且 Q 是正交的（透過 Gram-Schmidt 過程總可以得到這樣一個矩陣），那麼 x = inv(R) * (Q.T) * b。（然而，在 numpy 實踐中，我們只需使用 lstsq）。

>>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])
>>> A
array([[0, 1],
 [1, 1],
 [1, 1],
 [2, 1]])
>>> b = np.array([1, 2, 2, 3])
>>> Q, R = np.linalg.qr(A)
>>> p = np.dot(Q.T, b)
>>> np.dot(np.linalg.inv(R), p)
array([  1.,   1.]) 

numpy.linalg.svd

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.svd.html

linalg.svd(a, full_matrices=True, compute_uv=True, hermitian=False)

奇異值分解。

當a是 2D 陣列，且full_matrices=False，則將其分解為u @ np.diag(s) @ vh = (u * s) @ vh，其中u和vh的共軛轉置是具有標準正交列的 2D 陣列，s是a的奇異值的 1D 陣列。當a是更高維度時，將以堆疊模式進行奇異值分解，如下所述。

引數：

a(…, M, N)陣列型

具有a.ndim >= 2的實數或複數陣列。

full_matricesbool, optional

如果為 True（預設值），u和vh的形狀分別為(..., M, M)和(..., N, N)。否則，形狀分別為(..., M, K)和(..., K, N)，其中K = min(M, N)。

compute_uvbool, optional

是否計算u和vh以及s。預設值為 True。

hermitianbool, optional

如果為 True，則假定a是厄米（實值情況下為對稱的），從而可以更有效地找到奇異值。預設為 False。

1.17.0 版本中的新增內容。

返回：

當compute_uv為 True 時，結果將是具有以下屬性的命名元組

屬性名稱：

U陣列

單位陣列。前a.ndim - 2維具有與輸入a相同的大小。最後兩個維度的大小取決於full_matrices的值。僅在compute_uv為 True 時返回。

S(…, K)陣列

各向量的奇異值，每個向量按降序排序。前a.ndim - 2維與輸入a的大小相同。

Vh陣列

單位陣列。前a.ndim - 2維具有與輸入a相同的大小。最後兩個維度的大小取決於full_matrices的值。僅在compute_uv為 True 時返回。

引發：

LinAlgError

如果 SVD 計算無法收斂。

另請參見

scipy.linalg.svd

SciPy 中的類似函式。

scipy.linalg.svdvals

計算矩陣的奇異值。

註釋

在 1.8.0 版本中更改：廣播規則適用，有關詳細資訊，請參閱numpy.linalg文件。

使用 LAPACK 例程_gesdd執行分解。

SVD 通常用於分解二維矩陣(A)。下面將討論高維情況。在二維情況下，SVD 表示為(A = U S V^H)，其中(A = a)，(U= u)，(S= \mathtt{np.diag}(s))和(V^H = vh)。一維陣列s包含a的奇異值，u和vh是酉矩陣。vh的行是(A^H A)的特徵向量，u的列是(A A^H)的特徵向量。在這兩種情況下，相應的（可能非零）特徵值由s**2給出。

如果a的維數超過兩個，則應用廣播規則，如同時對多個矩陣進行線性代數運算中所解釋的那樣。這意味著 SVD 以“堆疊”模式工作：它遍歷第一個a.ndim - 2維的所有索引，對於每個組合，SVD 應用於最後兩個索引。矩陣a可以使用(u * s[..., None, :]) @ vh或u @ (s[..., None] * vh)重構分解。（對於 Python 版本低於 3.5，@運算子可以被函式np.matmul替換。）

如果a是一個matrix物件（而不是一個ndarray），那麼所有返回值也是。

示例

>>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)
>>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3) 

基於完整 SVD 的重構，二維情況：

>>> U, S, Vh = np.linalg.svd(a, full_matrices=True)
>>> U.shape, S.shape, Vh.shape
((9, 9), (6,), (6, 6))
>>> np.allclose(a, np.dot(U[:, :6] * S, Vh))
True
>>> smat = np.zeros((9, 6), dtype=complex)
>>> smat[:6, :6] = np.diag(S)
>>> np.allclose(a, np.dot(U, np.dot(smat, Vh)))
True 

基於降維 SVD 的重構，二維情況：

>>> U, S, Vh = np.linalg.svd(a, full_matrices=False)
>>> U.shape, S.shape, Vh.shape
((9, 6), (6,), (6, 6))
>>> np.allclose(a, np.dot(U * S, Vh))
True
>>> smat = np.diag(S)
>>> np.allclose(a, np.dot(U, np.dot(smat, Vh)))
True 

基於完整 SVD 的重構，四維情況：

>>> U, S, Vh = np.linalg.svd(b, full_matrices=True)
>>> U.shape, S.shape, Vh.shape
((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
>>> np.allclose(b, np.matmul(U[..., :3] * S[..., None, :], Vh))
True
>>> np.allclose(b, np.matmul(U[..., :3], S[..., None] * Vh))
True 

基於降維 SVD 的重構，四維情況：

>>> U, S, Vh = np.linalg.svd(b, full_matrices=False)
>>> U.shape, S.shape, Vh.shape
((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
>>> np.allclose(b, np.matmul(U * S[..., None, :], Vh))
True
>>> np.allclose(b, np.matmul(U, S[..., None] * Vh))
True 

numpy.linalg.eig

numpy.org/doc/1.26/reference/generated/numpy.linalg.eig.html

linalg.eig(a)

計算方陣的特徵值和右特徵向量。

引數:

a(…, M, M) 陣列

將計算特徵值和右特徵向量的矩陣

返回:

具有以下屬性的命名元組:

特徵值(…, M) 陣列

每個特徵值根據其重數重複。特徵值不一定有序。結果陣列將是複雜型，除非虛部為零，那麼它將被轉換為實型。當 a 是真實的時，生成的特徵值將是實數（虛部為零）或成共軛對。

eigenvectors(…, M, M) 陣列

規範化的（單位“長度”）特徵向量，使得列 eigenvectors[:,i] 是對應於特徵值 eigenvalues[i] 的特徵向量。

引發:

LinAlgError

如果特徵值計算不收斂。

另請參閱

eigvals

非對稱陣列的特徵值。

eigh

實對稱或復 Hermitian（共軛對稱）陣列的特徵值和特徵向量。

eigvalsh

實對稱或復 Hermitian（共軛對稱）陣列的特徵值。

scipy.linalg.eig

SciPy 中的類似功能還解決了廣義特徵值問題。

scipy.linalg.schur

對於酉矩陣和其他非 Hermitian 正規矩陣的最佳選擇。

注意

1.8.0 版中的新功能。

廣播規則適用，請參閱 numpy.linalg 文件以瞭解詳細資訊。

這是使用 _geev LAPACK 例程實現的，該例程計算一般方陣的特徵值和特徵向量。

w 的數字是 a 的特徵值，如果存在一個向量 v 使得 a @ v = w * v。因此，陣列 a，eigenvalues 和 eigenvectors 滿足等式 a @ eigenvectors[:,i] = eigenvalues[i] * eigenvalues[:,i] 對於(i \in {0,...,M-1})。

eigenvectors 陣列可能不是最大秩的，也就是說，一些列可能線性相關，儘管四捨五入錯誤可能掩蓋了這一事實。如果特徵值都不同，那麼理論上特徵向量是線性無關的，a 可以透過使用 eigenvectors 的相似變換對角化，即 inv(eigenvectors) @ a @ eigenvectors 為對角線。

對於非埃爾米特正規矩陣，推薦使用 SciPy 函式scipy.linalg.schur，因為這將確保矩陣eigenvectors是么正的，而使用eig時並非如此。舒爾分解產生一個上三角矩陣而不是對角矩陣，但對於正規矩陣，只需要上三角矩陣的對角線部分，剩下的是四捨五入誤差。

最後，強調了eigenvectors由a的 right（即右側）特徵向量組成。滿足 y.T @ a = z * y.T 的向量y為a的left特徵向量，一般來說，矩陣的左特徵向量和右特徵向量並不一定是（可能是共軛）轉置關係。

參考資料

G. Strang，《線性代數及其應用》，第 2 版，Orlando, FL, Academic Press, Inc., 1980, 各種頁碼。

示例

>>> from numpy import linalg as LA 

具有實特徵值和特徵向量的（幾乎）平凡示例。

>>> eigenvalues, eigenvectors = LA.eig(np.diag((1, 2, 3)))
>>> eigenvalues
array([1., 2., 3.])
>>> eigenvectors
array([[1., 0., 0.],
 [0., 1., 0.],
 [0., 0., 1.]]) 

具有復特徵值和特徵向量的實矩陣；注意特徵值互為共軛複數。

>>> eigenvalues, eigenvectors = LA.eig(np.array([[1, -1], [1, 1]]))
>>> eigenvalues
array([1.+1.j, 1.-1.j])
>>> eigenvectors
array([[0.70710678+0.j        , 0.70710678-0.j        ],
 [0\.        -0.70710678j, 0\.        +0.70710678j]]) 

具有實特徵值的複數矩陣（但特徵向量是複數）；注意 a.conj().T == a，即，a 是埃爾米特矩陣。

>>> a = np.array([[1, 1j], [-1j, 1]])
>>> eigenvalues, eigenvectors = LA.eig(a)
>>> eigenvalues
array([2.+0.j, 0.+0.j])
>>> eigenvectors
array([[ 0\.        +0.70710678j,  0.70710678+0.j        ], # may vary
 [ 0.70710678+0.j        , -0\.        +0.70710678j]]) 

要小心四捨五入誤差！

>>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]])
>>> # Theor. eigenvalues are 1 +/- 1e-9
>>> eigenvalues, eigenvectors = LA.eig(a)
>>> eigenvalues
array([1., 1.])
>>> eigenvectors
array([[1., 0.],
 [0., 1.]]) 

numpy.linalg.eigh

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.eigh.html

linalg.eigh(a, UPLO='L')

返回復 Hermite（共軛對稱）或實對稱矩陣的特徵值和特徵向量。

返回兩個物件，一個包含 a 的特徵值的一維陣列，以及相應特徵向量（按列排列）的二維方陣或矩陣（取決於輸入型別）。

引數：

a(…, M, M) 陣列

要計算其特徵值和特徵向量的 Hermite 或實對稱矩陣。

UPLO, 可選

指定計算是使用 a 的下三角部分（‘L’，預設）還是上三角部分（‘U’）。無論這個值是什麼，對角線的實部將被考慮在內以保持 Hermite 矩陣的概念。因此，對角線的虛部將始終被視為零。

返回：

具有以下屬性的命名元組：

eigenvalues(…, M) 陣列

按升序排列的特徵值，每個根據其重數重複。

eigenvectors

列 eigenvectors[:, i] 是與特徵值 eigenvalues[i] 對應的歸一化特徵向量。如果 a 是一個矩陣物件，則會返回一個矩陣物件。

引發：

LinAlgError

如果特徵值計算不收斂。

另請參見

eigvalsh

實對稱或復 Hermite（共軛對稱）陣列的特徵值。

eig

非對稱陣列的特徵值和右特徵向量。

eigvals

非對稱陣列的特徵值。

scipy.linalg.eigh

SciPy 中的類似函式（但也解決了廣義特徵值問題）。

注意事項

自版本 1.8.0 新增。

廣播規則適用，請參閱numpy.linalg文件以獲取詳細資訊。

使用 LAPACK 程式 _syevd、_heevd 計算特徵值/特徵向量。

實對稱或復 Hermite 矩陣的特徵值始終為實數。[1]（列）特徵向量的陣列 eigenvalues 是么正的，a、eigenvalues 和 eigenvectors 滿足方程 dot(a, eigenvectors[:, i]) = eigenvalues[i] * eigenvectors[:, i]。

參考資料

[1]

G. Strang，《線性代數及其應用》，第 2 版，奧蘭多，FL，Academic Press, Inc.，1980 年，第 222 頁。

示例

>>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> a
array([[ 1.+0.j, -0.-2.j],
 [ 0.+2.j,  5.+0.j]])
>>> eigenvalues, eigenvectors = LA.eigh(a)
>>> eigenvalues
array([0.17157288, 5.82842712])
>>> eigenvectors
array([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary
 [ 0\.        +0.38268343j,  0\.        -0.92387953j]]) 

>>> np.dot(a, eigenvectors[:, 0]) - eigenvalues[0] * eigenvectors[:, 0] # verify 1st eigenval/vec pair
array([5.55111512e-17+0.0000000e+00j, 0.00000000e+00+1.2490009e-16j])
>>> np.dot(a, eigenvectors[:, 1]) - eigenvalues[1] * eigenvectors[:, 1] # verify 2nd eigenval/vec pair
array([0.+0.j, 0.+0.j]) 

>>> A = np.matrix(a) # what happens if input is a matrix object
>>> A
matrix([[ 1.+0.j, -0.-2.j],
 [ 0.+2.j,  5.+0.j]])
>>> eigenvalues, eigenvectors = LA.eigh(A)
>>> eigenvalues
array([0.17157288, 5.82842712])
>>> eigenvectors
matrix([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary
 [ 0\.        +0.38268343j,  0\.        -0.92387953j]]) 

>>> # demonstrate the treatment of the imaginary part of the diagonal
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
array([[5.+2.j, 9.-2.j],
 [0.+2.j, 2.-1.j]])
>>> # with UPLO='L' this is numerically equivalent to using LA.eig() with:
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
array([[5.+0.j, 0.-2.j],
 [0.+2.j, 2.+0.j]])
>>> wa, va = LA.eigh(a)
>>> wb, vb = LA.eig(b)
>>> wa; wb
array([1., 6.])
array([6.+0.j, 1.+0.j])
>>> va; vb
array([[-0.4472136 +0.j        , -0.89442719+0.j        ], # may vary
 [ 0\.        +0.89442719j,  0\.        -0.4472136j ]])
array([[ 0.89442719+0.j       , -0\.        +0.4472136j],
 [-0\.        +0.4472136j,  0.89442719+0.j       ]]) 

numpy.linalg.eigvals

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.eigvals.html

linalg.eigvals(a)

計算一般矩陣的特徵值。

eigvals 和 eig 的主要區別：沒有返回特徵向量。

引數：

a(…, M, M) array_like

一個復值或實值矩陣，將計算其特徵值。

返回：

w(…, M,) ndarray

每個特徵值，根據其重數重複。它們不一定有序，也不一定是實數矩陣的實數。

引發：

LinAlgError

如果特徵值計算不收斂。

參見

eig

一般陣列的特徵值和右特徵向量

eigvalsh

實對稱或復埃爾米特（共軛對稱）陣列的特徵值。

eigh

實對稱或復埃爾米特（共軛對稱）陣列的特徵值和特徵向量。

scipy.linalg.eigvals

SciPy 中類似的函式。

註釋

新版本 1.8.0 中新增。

廣播規則適用，請參閱numpy.linalg文件以獲取詳細資訊。

這是使用 _geev LAPACK 程式包實現的，它計算一般方陣的特徵值和特徵向量。

示例

說明，利用對角矩陣的特徵值是其對角元素，將一個矩陣左乘以正交矩陣 Q，右乘以 Q.T（Q 的轉置）會保留“中間”矩陣的特徵值。換句話說，如果 Q 是正交的，則 Q * A * Q.T 的特徵值與 A 相同：

>>> from numpy import linalg as LA
>>> x = np.random.random()
>>> Q = np.array([[np.cos(x), -np.sin(x)], [np.sin(x), np.cos(x)]])
>>> LA.norm(Q[0, :]), LA.norm(Q[1, :]), np.dot(Q[0, :],Q[1, :])
(1.0, 1.0, 0.0) 

現在在一側用 Q 乘以對角矩陣，另一側用 Q.T 乘以對角矩陣：

>>> D = np.diag((-1,1))
>>> LA.eigvals(D)
array([-1.,  1.])
>>> A = np.dot(Q, D)
>>> A = np.dot(A, Q.T)
>>> LA.eigvals(A)
array([ 1., -1.]) # random 

numpy.linalg.eigvalsh

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.eigvalsh.html

linalg.eigvalsh(a, UPLO='L')

計算一個複共軛對稱或實對稱矩陣的特徵值。

與 eigh 的主要區別：不計算特徵向量。

引數：

a(…, M, M) array_like

待計算其特徵值的複數或實數值矩陣。

UPLO, 可選

指定是否使用a的下三角部分（‘L’，預設）或上三角部分（‘U’）進行計算。無論該值是什麼，對角線的實部都將在計算中被考慮，以保持複共軛矩陣的概念。因此，對角線的虛部始終被視為零。

返回:

w(…, M,) 陣列

特徵值按升序排列，根據其重數重複。

引發：

LinAlgError

如果特徵值計算沒有收斂。

另請參閱

eigh

實對稱或複共軛（共軛對稱）陣列的特徵值和特徵向量。

eigvals

一般實數或複數陣列的特徵值。

eig

一般實數或複數陣列的特徵值和右特徵向量。

scipy.linalg.eigvalsh

SciPy 中的類似函式。

注意

自版本 1.8.0 起的新功能。

廣播規則適用，詳情請參閱numpy.linalg文件。

特徵值是使用 LAPACK 例程_syevd、_heevd計算的。

示例

>>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> LA.eigvalsh(a)
array([ 0.17157288,  5.82842712]) # may vary 

>>> # demonstrate the treatment of the imaginary part of the diagonal
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
array([[5.+2.j, 9.-2.j],
 [0.+2.j, 2.-1.j]])
>>> # with UPLO='L' this is numerically equivalent to using LA.eigvals()
>>> # with:
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
array([[5.+0.j, 0.-2.j],
 [0.+2.j, 2.+0.j]])
>>> wa = LA.eigvalsh(a)
>>> wb = LA.eigvals(b)
>>> wa; wb
array([1., 6.])
array([6.+0.j, 1.+0.j]) 

numpy.linalg.norm

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.norm.html

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

矩陣或向量範數。

此函式能根據ord引數的值返回 8 種不同的矩陣範數，或者無窮多個向量範數（見下文）。

引數：

xarray_like

輸入陣列。如果axis為 None，則x必須是 1-D 或 2-D，除非ord為 None。如果axis和ord都為 None，則返回x.ravel的 2-範數。

ord，可選

範數的次序（見Notes下的表）。inf 表示 numpy 的inf物件。預設為 None。

axis, 可選。

如果axis是整數，則指定沿著x計算向量範數的軸。如果axis是一個二元組，則指定儲存 2-D 矩陣的軸，並計算這些矩陣的矩陣範數。如果axis為 None，則返回向量範數（當x為 1-D）或矩陣範數（當x為 2-D）。預設為 None。

新版 1.8.0 中新增。

keepdimsbool, 可選

如果設定為 True，則規範化的軸將作為尺寸為 1 的維度保留在結果中。使用此選項，結果將正確地廣播到原始x。

新版 1.10.0 中新增。

返回：

nfloat or ndarray

矩陣或向量的範數。

另請參閱

scipy.linalg.norm

SciPy 中的類似函式。

注意

對於ord < 1的值，���格地說，結果不是數學上的‘範數’，但對於各種數值目的仍然可能有用。

可計算如下範數：

ord	矩陣的範數	向量的範數
None	弗羅貝尼烏斯範數	2-範數
‘fro’	弗羅貝尼烏斯範數	–
‘nuc’	核範數	–
inf	最大值（沿 axis=1 的絕對值之和）	最大值（絕對值）
-inf	最小值（沿 axis=1 的絕對值之和）	最小值（絕對值）
0	–	sum(x != 0)
1	最大值（沿 axis=0 的絕對值之和）	如下
-1	最小值（沿 axis=0 的絕對值之和）	如下
2	2-範數（最大奇異值）	如下
-2	最小奇異值	如下
其它	–	sum(abs(x)ord)(1./ord)

弗羅貝尼烏斯範數由[1]給出：

(||A||F = [\sum abs(a_{i,j})²]^{1/2})

核範數是奇異值的和。

弗羅貝尼烏斯和核範數順序僅對矩陣定義，並且當x.ndim != 2時引發 ValueError。

參考

[1]

G. H. Golub 和 C. F. Van Loan，Matrix Computations，Baltimore，MD，約翰霍普金斯大學出版社，1985 年，第 15 頁

示例

>>> from numpy import linalg as LA
>>> a = np.arange(9) - 4
>>> a
array([-4, -3, -2, ...,  2,  3,  4])
>>> b = a.reshape((3, 3))
>>> b
array([[-4, -3, -2],
 [-1,  0,  1],
 [ 2,  3,  4]]) 

>>> LA.norm(a)
7.745966692414834
>>> LA.norm(b)
7.745966692414834
>>> LA.norm(b, 'fro')
7.745966692414834
>>> LA.norm(a, np.inf)
4.0
>>> LA.norm(b, np.inf)
9.0
>>> LA.norm(a, -np.inf)
0.0
>>> LA.norm(b, -np.inf)
2.0 

>>> LA.norm(a, 1)
20.0
>>> LA.norm(b, 1)
7.0
>>> LA.norm(a, -1)
-4.6566128774142013e-010
>>> LA.norm(b, -1)
6.0
>>> LA.norm(a, 2)
7.745966692414834
>>> LA.norm(b, 2)
7.3484692283495345 

>>> LA.norm(a, -2)
0.0
>>> LA.norm(b, -2)
1.8570331885190563e-016 # may vary
>>> LA.norm(a, 3)
5.8480354764257312 # may vary
>>> LA.norm(a, -3)
0.0 

使用axis引數來計算向量範數：

>>> c = np.array([[ 1, 2, 3],
...               [-1, 1, 4]])
>>> LA.norm(c, axis=0)
array([ 1.41421356,  2.23606798,  5\.        ])
>>> LA.norm(c, axis=1)
array([ 3.74165739,  4.24264069])
>>> LA.norm(c, ord=1, axis=1)
array([ 6.,  6.]) 

使用axis引數來計算矩陣範數：

>>> m = np.arange(8).reshape(2,2,2)
>>> LA.norm(m, axis=(1,2))
array([  3.74165739,  11.22497216])
>>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
(3.7416573867739413, 11.224972160321824) 

numpy.linalg.cond

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.cond.html

linalg.cond(x, p=None)

計算矩陣的條件數。

該函式能夠使用七種不同的範數之一返回條件數，具體取決於p的值（參見下面的引數）。

引數：

x(…, M, N) array_like

尋找條件數的矩陣。

p, 可選

用於計算條件數的範數的階數：

p	矩陣的範數
---	---
None	2-範數，直接使用 SVD 計算
‘fro’	Frobenius 範數
inf	max(sum(abs(x), axis=1))
-inf	min(sum(abs(x), axis=1))
1	max(sum(abs(x), axis=0))
-1	min(sum(abs(x), axis=0))
2	2-範數（最大奇異值）
-2	最小奇異值

inf 表示 numpy.inf 物件，Frobenius 範數是平方和的平方根範數。

返回：

c

矩陣的條件數。可能是無窮大。

請參閱

numpy.linalg.norm

注意事項

x的條件數被定義為x的範數乘以x的逆的範數[1]；該範數可以是通常的 L2 範數（平方和的平方根），或者是其他許多矩陣範數之一。

參考文獻

[1]

G. Strang，《線性代數及其應用》，Orlando, FL, Academic Press, Inc., 1980, pg. 285。

示例

>>> from numpy import linalg as LA
>>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]])
>>> a
array([[ 1,  0, -1],
 [ 0,  1,  0],
 [ 1,  0,  1]])
>>> LA.cond(a)
1.4142135623730951
>>> LA.cond(a, 'fro')
3.1622776601683795
>>> LA.cond(a, np.inf)
2.0
>>> LA.cond(a, -np.inf)
1.0
>>> LA.cond(a, 1)
2.0
>>> LA.cond(a, -1)
1.0
>>> LA.cond(a, 2)
1.4142135623730951
>>> LA.cond(a, -2)
0.70710678118654746 # may vary
>>> min(LA.svd(a, compute_uv=False))*min(LA.svd(LA.inv(a), compute_uv=False))
0.70710678118654746 # may vary 

numpy.linalg.det

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.det.html

linalg.det(a)

計算陣列的行列式。

引數：

a(…, M, M) array_like

輸入用於計算行列式的陣列。

返回：

det(…) array_like

a 的行列式。

參見

slogdet

另一種表示行列式的方式，更適用於可能發生下溢/上溢的大矩陣。

scipy.linalg.det

SciPy 中類似的函式。

注意事項

新版本 1.8.0 中增加。

廣播規則適用，請參閱numpy.linalg 文件瞭解詳情。

透過使用 LAPACK 例程 z/dgetrf 進行 LU 分解來計算行列式。

示例

2-D 陣列[[a, b], [c, d]] 的行列式是 ad - bc：

>>> a = np.array([[1, 2], [3, 4]])
>>> np.linalg.det(a)
-2.0 # may vary 

計算一組矩陣的行列式：

>>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
>>> a.shape
(3, 2, 2)
>>> np.linalg.det(a)
array([-2., -3., -8.]) 

numpy.linalg.matrix_rank

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.matrix_rank.html

linalg.matrix_rank(A, tol=None, hermitian=False)

使用 SVD 方法返回陣列的矩陣秩

陣列的秩是大於 tol 的奇異值的數量。

版本 1.14 中的更改：現在可以對矩陣棧進行操作

引數：

A 類陣列

輸入向量或矩陣棧。

tol（…）類陣列，浮點數，可選

SVD 值低於此閾值被視為零。如果 tol 為 None，且 S 為 M 的奇異值陣列，eps 為 S 的資料型別的 epsilon 值，則將 tol 設定為 S.max() * max(M, N) * eps。

版本 1.14 中的更改：可廣播與矩陣棧

hermitianbool，可選

如果為 True，則假定 A 是共軛（如果為實值，則為對稱），從而可以更有效地找到奇異值。預設值為 False。

版本 1.14 中的新功能。

返回：

rank(…) 類陣列

A 的秩。

注意事項

用於檢測秩缺陷的預設閾值是對 A 的奇異值的幅度的測試。預設情況下，我們將小於 S.max() * max(M, N) * eps 的奇異值視為指示秩缺陷（使用上述符號）。這是 MATLAB 使用的演算法[1]。它也出現在 Numerical recipes 中，討論線性最小二乘的 SVD 解[2]。

這種預設閾值旨在檢測秩缺陷，並考慮了 SVD 計算的數值誤差。假設 A 中有一列是其他列的精確（在浮點數中）線性組合。在 A 上計算 SVD 通常不會產生一個完全等於 0 的奇異值：最小奇異值與 0 的差異將是由於計算 SVD 時的數值精度導致的。我們對較小的奇異值的閾值考慮了這種數值精度，並且預設閾值將檢測到此類數值秩缺陷。即使 A 的某些列的線性組合與 A 的另一列並不完全相等，而只是在數值上非常接近 A 的另一列，該閾值也可以宣告矩陣 A 具有秩缺陷。

我們選擇我們的預設閾值，因為它被廣泛使用。其他閾值也是可能的。例如，Numerical recipes 的 2007 版本中還有一個備選閾值為 S.max() * np.finfo(A.dtype).eps / 2. * np.sqrt(m + n + 1.)。作者將此閾值描述為基於“預期舍入誤差”（p 71）。

以上閾值涉及在計算 SVD 時浮點舍入誤差的處理。然而，你可能對A中誤差源有更多資訊，這會讓你考慮其他的容差值以檢測有效的秩缺乏。最有用的容差度量取決於你打算在矩陣上執行的操作。例如，如果你的資料來自不確定測量，且不確定性大於浮點 epsilon，那麼選擇接近該不確定性的容差可能更好。如果不確定性是絕對而非相對的，則容差可以是絕對的。

參考文獻

[1]

MATLAB 參考文件，“秩” www.mathworks.com/help/techdoc/ref/rank.html

[2]

W. H. Press, S. A. Teukolsky, W. T. Vetterling 和 B. P. Flannery，“Numerical Recipes (第 3 版)”，劍橋大學出版社，2007 年，第 795 頁。

示例

>>> from numpy.linalg import matrix_rank
>>> matrix_rank(np.eye(4)) # Full rank matrix
4
>>> I=np.eye(4); I[-1,-1] = 0. # rank deficient matrix
>>> matrix_rank(I)
3
>>> matrix_rank(np.ones((4,))) # 1 dimension - rank 1 unless all 0
1
>>> matrix_rank(np.zeros((4,)))
0 

numpy.linalg.slogdet

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.slogdet.html

linalg.slogdet(a)

計算陣列的符號和（自然）對數行列式。

如果一個陣列的行列式非常小或非常大，則對det的呼叫可能會溢位或下溢。這個程式更健壯，因為它計算的是行列式的對數而不是行列式本身。

引數：

a(…, M, M) 陣列型

輸入陣列，必須是二維方陣。

返回：

具有以下屬性的命名元組：

sign(…) 陣列型

表示行列式符號的數字。對於實矩陣，這是 1、0 或 -1。對於復矩陣，這是絕對值為 1 的複數（即在單位圓上），否則為 0。

logabsdet(…) 陣列型

行列式的自然對數絕對值。

如果行列式為零，則sign將為 0，logabsdet 將為

-Inf。在所有情況下，行列式等於sign * np.exp(logabsdet)。

請參閱

det

注意

新版本 1.8.0。

廣播規則適用，請參閱numpy.linalg文件以瞭解詳情。

新版本 1.6.0。

透過使用 LAPACK 程式z/dgetrf進行 LU 分解計算行列式。

例子

二維陣列[[a, b], [c, d]]的行列式是ad - bc：

>>> a = np.array([[1, 2], [3, 4]])
>>> (sign, logabsdet) = np.linalg.slogdet(a)
>>> (sign, logabsdet)
(-1, 0.69314718055994529) # may vary
>>> sign * np.exp(logabsdet)
-2.0 

為一堆矩陣計算對數行列式：

>>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
>>> a.shape
(3, 2, 2)
>>> sign, logabsdet = np.linalg.slogdet(a)
>>> (sign, logabsdet)
(array([-1., -1., -1.]), array([ 0.69314718,  1.09861229,  2.07944154]))
>>> sign * np.exp(logabsdet)
array([-2., -3., -8.]) 

這個程式成功了普通的det沒有成功的地方：

>>> np.linalg.det(np.eye(500) * 0.1)
0.0
>>> np.linalg.slogdet(np.eye(500) * 0.1)
(1, -1151.2925464970228) 

numpy.trace

原文：numpy.org/doc/1.26/reference/generated/numpy.trace.html

numpy.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)

返回陣列沿對角線的總和。

如果 a 是 2-D，則返回沿其對角線的總和，並給定偏移量，即，所有 i 的元素 a[i,i+offset] 的和。

如果 a 大於兩個維度，則由 axis1 和 axis2 指定的軸用於確定返回的跡為 2-D 子陣列。返回陣列的形狀與 a 相同，但刪除了 axis1 和 axis2。

引數:

a 類似陣列

被取對角線的輸入陣列。

offset 整數，可選

與主對角線的偏移量。可以為正數或負數。預設為 0。

axis1, axis2 整數，可選

用作應該獲取對角線的 2-D 子陣列的第一個和第二個軸的軸。預設為 a 的前兩軸。

dtype 資料型別，可選

確定返回陣列的資料型別以及元素求和的累加器的資料型別。如果 dtype 的值為 None，並且 a 是小於預設整數精度的整數型別，則使用預設整數精度。否則，精度與 a 的精度相同。

out 陣列，可選

陣列，其輸出需放置的位置。其型別保持不變，必須具有正確的形狀以容納輸出。

返回:

sum_along_diagonals 陣列

如果 a 是 2-D，則返回沿對角線的總和。如果 a 的維度更大，則返回沿對角線的總和陣列。

另請參見

diag, diagonal, diagflat

示例

>>> np.trace(np.eye(3))
3.0
>>> a = np.arange(8).reshape((2,2,2))
>>> np.trace(a)
array([6, 8]) 

>>> a = np.arange(24).reshape((2,2,2,3))
>>> np.trace(a).shape
(2, 3) 

numpy.linalg.solve

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.solve.html

linalg.solve(a, b)

解線性矩陣方程或線性標量方程組。

計算線性矩陣方程 ax = b 的“精確”解 x。該方程確定性好，即滿秩。

引數：

a(…, M, M) 陣列

係數矩陣。

b，陣列樣式

縱座標或“因變數”值。

返回值：

x 陣列

系統 a x = b 的解。返回形狀與 b 相同。

引發錯誤：

線性代數錯誤

如果 a 是奇異的或不是方陣。

另請參見

scipy.linalg.solve

SciPy 中類似的函式。

注意事項

新版本 1.8.0 中新增。

適用於廣播規則，詳情請參見 numpy.linalg 文件。

使用 LAPACK 例程 _gesv 計算解。

a 必須是方陣且滿秩，即所有行（或等效地，列）必須線性獨立；如果不滿足這兩個條件，請使用 lstsq 求解系統/方程的最小二乘“解決方案”。

參考資料

[1]

G. Strang, 線性代數及其應用, 第 2 版，奧蘭多，FL，Academic Press，Inc。，1980 年，第 22 頁。

示例

解方程組 x0 + 2 * x1 = 1 和 3 * x0 + 5 * x1 = 2：

>>> a = np.array([[1, 2], [3, 5]])
>>> b = np.array([1, 2])
>>> x = np.linalg.solve(a, b)
>>> x
array([-1.,  1.]) 

檢查解的正確性：

>>> np.allclose(np.dot(a, x), b)
True 

numpy.linalg.tensorsolve

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.tensorsolve.html

linalg.tensorsolve(a, b, axes=None)

解張量方程a x = b，求解x。

假設x的所有索引在乘積中與a的最右邊的索引一起被求和，如在例如tensordot(a, x, axes=x.ndim)中所做的那樣。

引數：

a類似陣列

係數張量，形狀為b.shape + Q。Q，一個元組，等於a的子張量的形狀，其中包含適當數量的最右邊索引，並且必須滿足prod(Q) == prod(b.shape)（在這種意義上，a被稱為“方陣”）。

b類似陣列

右手張量，可以是任意形狀。

軸整數元組，可選

對a中的軸重新排序，以便在求逆之前將其移到正確位置。如果為 None（預設），則不進行重新排序。

返回：

x陣列，形狀 Q

異常：

LinAlgError

如果a是奇異的或不是“方陣”（在上述意義上）。

參見

numpy.tensordot, tensorinv, numpy.einsum

示例

>>> a = np.eye(2*3*4)
>>> a.shape = (2*3, 4, 2, 3, 4)
>>> b = np.random.randn(2*3, 4)
>>> x = np.linalg.tensorsolve(a, b)
>>> x.shape
(2, 3, 4)
>>> np.allclose(np.tensordot(a, x, axes=3), b)
True 

numpy.linalg.lstsq

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.lstsq.html

linalg.lstsq(a, b, rcond='warn')

返回線性矩陣方程的最小二乘解。

計算近似解方程 a @ x = b 的向量 x。方程可能是欠定的、完全確定的或過完全確定的（即，a 的線性獨立行數可能小於、等於或大於其線性獨立列數）。如果 a 是方的且滿秩的，則 x（除舍入誤差外）是方程的“精確”解。否則，x 最小化歐幾里德二範數 (||b - ax||)。如果有多個最小化解，則返回具有最小二範數 (||x||) 的解。

引數：

a(M, N) 類似陣列

“係數”矩陣。

b 類似陣列

縱座標或“因變數”值。如果 b 是二維的，則對 b 的每個 K 列計算最小二乘解。

rcond浮點數，可選

小奇異值的截斷比例 a。為了確定秩，如果奇異值小於 rcond 乘以 a 的最大奇異值，則將其視為零。

從 1.14.0 版更改：如果未設定，將給出 FutureWarning。以前的預設值 -1 將使用機器精度作為 rcond 引數，新預設值將使用機器精度乘以 max(M, N)。要消除警告並使用新預設值，請使用 rcond=None，要繼續使用舊行為，請使用 rcond=-1。

返回：

x 陣列

最小二乘解。如果 b 是二維的，則解在 x 的 K 列中。

殘差 陣列

殘差平方和：對 b - a @ x 中每一列的歐幾里德二範數進行平方。如果 a 的秩 < N 或 M <= N，則這是一個空陣列。如果 b 是一維的，那麼這是一個形狀為 (1,) 的陣列。否則形狀為 (K,)。

秩整數

a 矩陣的秩。

s(min(M, N),) 陣列

a 的奇異值。

引發：

LinAlgError

如果計算不收斂。

參見

scipy.linalg.lstsq

SciPy 中的類似函式。

註解

如果 b 是一個矩陣，則所有的陣列結果將作為矩陣返回。

例子

透過一些帶有噪音資料點的擬合直線，y = mx + c：

>>> x = np.array([0, 1, 2, 3])
>>> y = np.array([-1, 0.2, 0.9, 2.1]) 

透過檢查係數，我們發現線條的斜率大約為 1，並在縱軸上大致為-1 處相交。

我們可以將線性方程重寫為 y = Ap，其中 A = [[x 1]] 和 p = [[m], [c]]。現在使用 lstsq 解出 p：

>>> A = np.vstack([x, np.ones(len(x))]).T
>>> A
array([[ 0.,  1.],
 [ 1.,  1.],
 [ 2.,  1.],
 [ 3.,  1.]]) 

>>> m, c = np.linalg.lstsq(A, y, rcond=None)[0]
>>> m, c
(1.0 -0.95) # may vary 

繪製資料以及擬合的直線：

>>> import matplotlib.pyplot as plt
>>> _ = plt.plot(x, y, 'o', label='Original data', markersize=10)
>>> _ = plt.plot(x, m*x + c, 'r', label='Fitted line')
>>> _ = plt.legend()
>>> plt.show() 

../../_images/numpy-linalg-lstsq-1.png

numpy.linalg.inv

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.inv.html

linalg.inv(a)

計算矩陣的（乘法）逆。

給定一個方陣 a，返回滿足 dot(a, ainv) = dot(ainv, a) = eye(a.shape[0]) 的矩陣 ainv。

引數：

a(…, M, M) 陣列樣式

要求求逆的矩陣。

返回：

ainv(…, M, M) ndarray 或 矩陣

矩陣 a 的（乘法）逆。

引發：

LinAlgError

如果 a 不是方陣或求逆失敗。

另請參閱

scipy.linalg.inv

SciPy 中的類似函式。

註釋

1.8.0 版本中的新功能。

廣播規則適用，請參閱numpy.linalg文件以獲取詳細資訊。

示例

>>> from numpy.linalg import inv
>>> a = np.array([[1., 2.], [3., 4.]])
>>> ainv = inv(a)
>>> np.allclose(np.dot(a, ainv), np.eye(2))
True
>>> np.allclose(np.dot(ainv, a), np.eye(2))
True 

如果 a 是一個矩陣物件，那麼返回值也是一個矩陣：

>>> ainv = inv(np.matrix(a))
>>> ainv
matrix([[-2\. ,  1\. ],
 [ 1.5, -0.5]]) 

可以同時計算多個矩陣的逆：

>>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
>>> inv(a)
array([[[-2\.  ,  1\.  ],
 [ 1.5 , -0.5 ]],
 [[-1.25,  0.75],
 [ 0.75, -0.25]]]) 

numpy.linalg.pinv

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.pinv.html

linalg.pinv(a, rcond=1e-15, hermitian=False)

計算矩陣的（M-彭羅斯）偽逆。

使用奇異值分解（SVD）計算矩陣的廣義逆，幷包括所有大奇異值。

從版本 1.14 開始發生變化：現在可以操作矩陣堆疊

Parameters:

a(…, M, N) 陣列

要求偽逆的矩陣或矩陣堆疊。

rcond(…) 浮點數的陣列

小奇異值的截斷。小於或等於rcond * largest_singular_value的奇異值被設為零。廣播到矩陣堆疊。

hermitianbool, optional

如果為 True，則假定a是埃爾米特（如果為實值，則為對稱），從而可以更有效地找到奇異值的方法。 預設為 False。

版本 1.17.0 中的新功能。

Returns:

B(…, N, M) ndarray

a的偽逆。如果a是matrix例項，則B也是。

Raises:

LinAlgError

如果 SVD 計算無法收斂。

See also

scipy.linalg.pinv

SciPy 中的類似函式。

scipy.linalg.pinvh

計算埃爾米特矩陣的（M-彭羅斯）偽逆。

Notes

矩陣 A 的偽逆，表示為(A^+)，定義為：“‘解決’[最小二乘問題]的矩陣(Ax = b)”，即，如果(\bar{x})是所述解決方案，則(A^+)是那個矩陣，使得(\bar{x} = A^+b)。

可以表明，如果(Q_1 \Sigma Q_2^T = A)是 A 的奇異值分解，則(A^+ = Q_2 \Sigma^+ Q_1^T)，其中(Q_{1,2})是正交矩陣，(\Sigma)是由 A 的所謂奇異值構成的對角矩陣（通常後面是零），然後(\Sigma^+)是簡單地由 A 的奇異值的倒數構成的對角矩陣（同樣後面是零）。[1]

References

[1]

G. Strang，線性代數及其應用，第 2 版，奧蘭多，FL，學術出版社，1980 年，第 139-142 頁。

Examples

以下示例檢查a * a+ * a == a和a+ * a * a+ == a+是否成立：

>>> a = np.random.randn(9, 6)
>>> B = np.linalg.pinv(a)
>>> np.allclose(a, np.dot(a, np.dot(B, a)))
True
>>> np.allclose(B, np.dot(B, np.dot(a, B)))
True 

numpy.linalg.tensorinv

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.tensorinv.html

linalg.tensorinv(a, ind=2)

計算 N 維陣列的“逆”。

結果是相對於 tensordot 操作tensordot(a, b, ind)的a的逆，即，達到浮點精度，tensordot(tensorinv(a), a, ind)是 tensordot 操作的"單位"張量。

引數：

aarray_like

Tensor to ‘invert’. Its shape must be ‘square’, i. e., prod(a.shape[:ind]) == prod(a.shape[ind:]).

indint, 可選

參與逆求和的第一個索引的數量。必須是正整數，預設值為 2。

返回：

bndarray

a的 tensordot 逆，形狀為a.shape[ind:] + a.shape[:ind]。

丟擲：

LinAlgError

如果a是奇異的或者不是“方形”（在上述意義上）。

另請參閱

numpy.tensordot, tensorsolve

示例

>>> a = np.eye(4*6)
>>> a.shape = (4, 6, 8, 3)
>>> ainv = np.linalg.tensorinv(a, ind=2)
>>> ainv.shape
(8, 3, 4, 6)
>>> b = np.random.randn(4, 6)
>>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b))
True 

>>> a = np.eye(4*6)
>>> a.shape = (24, 8, 3)
>>> ainv = np.linalg.tensorinv(a, ind=1)
>>> ainv.shape
(8, 3, 24)
>>> b = np.random.randn(24)
>>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))
True 

numpy.linalg.LinAlgError

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.LinAlgError.html

exception linalg.LinAlgError

由 linalg 函式引發的通用 Python 異常衍生物件。

通用目的異常類，從 Python 的 ValueError 類派生，當線性代數相關條件會阻止函式進一步正確執行時，在 linalg 函式中以程式方式引發。

引數：

無

例子

>>> from numpy import linalg as LA
>>> LA.inv(np.zeros((2,2)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
 File "...linalg.py", line 350,
 in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 File "...linalg.py", line 249,
 in solve
 raise LinAlgError('Singular matrix')
numpy.linalg.LinAlgError: Singular matrix 

邏輯函式

原文：numpy.org/doc/1.26/reference/routines.logic.html

真值測試

all(a[, axis, out, keepdims, where])	測試陣列沿給定軸的所有元素是否都為 True。
any(a[, axis, out, keepdims, where])	測試陣列沿給定軸是否存在任意元素為 True。

陣列內容

isfinite(x, /[, out, where, casting, order, ...])	測試元素級是否為有限數(非無窮大且非 NaN)。
isinf(x, /[, out, where, casting, order, ...])	測試元素級是否為正無窮大或負無窮大。
isnan(x, /[, out, where, casting, order, ...])	測試元素級是否為 NaN，並以布林陣列形式返回結果。
isnat(x, /[, out, where, casting, order, ...])	測試元素級是否為非時間(NaT)，並以布林陣列形式返回結果。
isneginf(x[, out])	測試元素級是否為負無窮大，並以布林陣列形式返回結果。
isposinf(x[, out])	測試元素級是否為正無窮大，並以布林陣列形式返回結果。

陣列型別測試

iscomplex(x)	返回一個布林陣列，如果輸入元素是複數則為 True。
iscomplexobj(x)	檢查是否為複數型別或複數陣列。
isfortran(a)	檢查陣列是否為 Fortran 連續但不為 C 連續。
isreal(x)	返回一個布林陣列，如果輸入元素是實數則為 True。
isrealobj(x)	如果 x 是非複數型別或複數陣列，則返回 True。
isscalar(element)	如果 element 的型別是標量型別，則返回 True。

邏輯操作

logical_and(x1, x2, /[, out, where, ...])	逐元素計算 x1 和 x2 的真值。
logical_or(x1, x2, /[, out, where, casting, ...])	逐元素計算 x1 或 x2 的真值。
logical_not(x, /[, out, where, casting, ...])	逐元素計算 NOT x 的真值。
logical_xor(x1, x2, /[, out, where, ...])	逐元素計算 x1 XOR x2 的真值。

比較

allclose(a, b[, rtol, atol, equal_nan])	如果兩個陣列在容差內逐元素相等則返回 True。
isclose(a, b[, rtol, atol, equal_nan])	返回一個布林陣列，其中兩個陣列在容差內逐元素相等。
array_equal(a1, a2[, equal_nan])	如果兩個陣列具有相同的形狀和元素，則返回 True，否則返回 False。
array_equiv(a1, a2)	如果輸入陣列形狀一致且所有元素相等則返回 True。
greater(x1, x2, /[, out, where, casting, ...])	返回（x1 > x2）的逐元素真值。
greater_equal(x1, x2, /[, out, where, ...])	返回（x1 >= x2）的逐元素真值。
	less(x1, x2, /[, out, where, casting, ...])
less_equal(x1, x2, /[, out, where, casting, ...])	返回（x1 <= x2）的逐元素真值。
	equal(x1, x2, /[, out, where, casting, ...])
not_equal(x1, x2, /[, out, where, casting, ...])	逐元素返回（x1 != x2）。

真值測試

all(a[, axis, out, keepdims, where])	測試沿給定軸的所有陣列元素是否求值為 True。
	any(a[, axis, out, keepdims, where])

陣列內容

isfinite(x, /[, out, where, casting, order, ...])	逐元素測試是否為有限值（既不是無窮大也不是非數）。
isinf(x, /[, out, where, casting, order, ...])	逐元素測試是否為正無窮或負無窮。
isnan(x, /[, out, where, casting, order, ...])	逐元素測試是否為 NaN，並將結果作為布林陣列返回。
isnat(x, /[, out, where, casting, order, ...])	逐元素測試是否為 NaT（不是時間），並返回布林陣列結果。
isneginf(x[, out])	逐元素測試是否為負無窮大，返回布林陣列結果。
isposinf(x[, out])	逐元素測試是否為正無窮大，返回布林陣列結果。

陣列型別測試

iscomplex(x)	返回一個布林陣列，輸入元素為複數時返回 True。
iscomplexobj(x)	檢查複數型別或複數陣列。
isfortran(a)	檢查陣列是否是 Fortran 連續但不是C 連續。
isreal(x)	返回一個布林陣列，輸入元素為實數時返回 True。
isrealobj(x)	如果 x 是非複數型別或複數陣列，則返回 True。
isscalar(element)	如果 element 的型別是標量型別，則返回 True。

邏輯運算

logical_and(x1, x2, /[, out, where, ...])	逐元素計算 x1 AND x2 的真值。
logical_or(x1, x2, /[, out, where, casting, ...])	逐元素計算 x1 OR x2 的真值。
logical_not(x, /[, out, where, casting, ...])	逐元素計算 NOT x 的真值。
logical_xor(x1, x2, /[, out, where, ...])	逐元素計算 x1 XOR x2 的真值。

比較

allclose(a, b[, rtol, atol, equal_nan])	如果兩個陣列在容差範圍內逐元素相等，則返回 True。
isclose(a, b[, rtol, atol, equal_nan])	返回一個布林陣列，在容差範圍內兩個陣列逐元素相等。
array_equal(a1, a2[, equal_nan])	如果兩個陣列具有相同的形狀和元素，則為 True，否則為 False。
array_equiv(a1, a2)	如果輸入陣列形狀一致且所有元素相等，則返回 True。
greater(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 > x2) 的真值。
greater_equal(x1, x2, /[, out, where, ...])	返回逐元素 (x1 >= x2) 的真值。
less(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 < x2) 的真值。
less_equal(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 <= x2) 的真值。
equal(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 == x2) 的真值。
not_equal(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 != x2) 的真值。

numpy.all

原文：numpy.org/doc/1.26/reference/generated/numpy.all.html

numpy.all(a, axis=None, out=None, keepdims=<no value>, *, where=<no value>)

測試給定軸向的所有陣列元素是否評估為 True。

引數：

aarray_like

輸入陣列或可轉換為陣列的物件。

axisNone 或 int 或 int 的元組，可選

執行邏輯 AND 減少的軸或軸。預設值（axis=None）是對輸入陣列的所有維度執行邏輯 AND。axis可能是負數，此時它從最後一個軸計數到第一個軸。

在 1.7.0 版本中新增。

如果這是一個 int 的元組，則對多個軸執行減少操作，而不是像以前一樣對單個軸或所有軸執行減少操作。

outndarray，可選

替代輸出陣列，用於放置結果。它必須具有與期望輸出相同的形狀，並且其型別將被保留（例如，如果dtype(out)是 float，則結果將由 0.0 和 1.0 組成）。有關更多詳細資訊，請參見輸出型別確定。

keepdimsbool，可選

如果設定為 True，則被減少的軸會作為大小為一的維度保留在結果中。使用此選項，結果將正確地與輸入陣列進行廣播。

如果傳遞了預設值，則不會將keepdims傳遞給all的子類的方法，但任何非預設值都會。如果子類的方法未實現keepdims，則會引發任何異常。

wherebool 陣列，可選

用於檢查所有True值的元素。有關詳細資訊，請參見reduce。

在 1.20.0 版本中新增。

返回：

allndarray, bool

除非指定了out，否則將返回新的布林值或陣列，其中out的引用將被返回。

另請參見

ndarray.all

等效方法

any

測試給定軸向的任何元素是否評估為 True。

注意

不是數字（NaN）、正無窮大和負無窮大的計算結果為True，因為它們不等於零。

示例

>>> np.all([[True,False],[True,True]])
False 

>>> np.all([[True,False],[True,True]], axis=0)
array([ True, False]) 

>>> np.all([-1, 4, 5])
True 

>>> np.all([1.0, np.nan])
True 

>>> np.all([[True, True], [False, True]], where=[[True], [False]])
True 

>>> o=np.array(False)
>>> z=np.all([-1, 4, 5], out=o)
>>> id(z), id(o), z
(28293632, 28293632, array(True)) # may vary