文章目錄

• NumPy 教程
• NumPy Ndarray 對象
• NumPy 數據類型
• • 數據類型對象 (dtype)
• NumPy 讀取數據
• NumPy 數組屬性
• • • ndarray.ndim
    • ndarray.shape
    • ndarray.itemsize
    • ndarray.flags
• NumPy 創建數組
• • • numpy.empty
    • numpy.zeros
    • numpy.ones
• NumPy 從已有的數組創建數組
• • • numpy.asarray
    • numpy.frombuffer
    • numpy.fromiter
• NumPy 從數值范圍創建數組
• • • numpy.arange
    • numpy.linspace
    • numpy.logspace
• NumPy 切片和索引
• NumPy 高級索引
• • • 布爾索引
    • 花式索引
• NumPy 廣播(Broadcast)
• • • 廣播的規則:
• NumPy 迭代數組
• • • 控制遍歷順序
    • 修改數組中元素的值
    • 使用外部循環
    • 廣播迭代
  • 修改數組形狀
  • • numpy.reshape
    • numpy.ndarray.flat
    • numpy.ndarray.flatten
    • numpy.ravel
  • 翻轉數組
  • • numpy.transpose
    • numpy.rollaxis
    • numpy.swapaxes
  • 修改數組維度
  • • numpy.broadcast
    • numpy.broadcast_to
    • numpy.expand_dims
    • numpy.squeeze
  • 連接數組
  • • numpy.concatenate
    • numpy.stack
    • numpy.hstack
    • numpy.vstack
  • 分割數組
  • • numpy.split
    • numpy.hsplit
    • numpy.vsplit
  • 數組元素的添加與刪除
  • • numpy.resize
    • numpy.append
    • numpy.insert
    • numpy.delete
    • numpy.unique
• NumPy 位運算
• • • bitwise_and
    • bitwise_or
    • invert
    • left_shift
    • right_shift
• NumPy 字符串函數
• • • numpy.char.add()
    • numpy.char.multiply()
    • numpy.char.center()
    • numpy.char.capitalize()
    • numpy.char.title()
    • numpy.char.lower()
    • numpy.char.upper()
    • numpy.char.split()
    • numpy.char.splitlines()
    • numpy.char.strip()
    • numpy.char.join()
    • numpy.char.replace()
    • numpy.char.encode()
    • numpy.char.decode()
• NumPy 數學函數
• • • 三角函數
    • 舍入函數
    • numpy.floor()
    • numpy.ceil()
• NumPy 算術函數
• • • numpy.reciprocal()
    • numpy.power()
    • numpy.mod()
• NumPy 統計函數
• • • numpy.amin() 和 numpy.amax()
    • numpy.ptp()
    • numpy.percentile()
    • numpy.median()
    • numpy.mean()
    • numpy.average()
    • 標準差
    • 方差
• NumPy 排序、條件刷選函數
• • • numpy.sort()
    • numpy.argsort()
    • numpy.lexsort()
    • msort、sort_complex、partition、argpartition
    • numpy.argmax() 和 numpy.argmin()
    • numpy.nonzero()
    • numpy.where()
    • numpy.extract()
• NumPy 字節交換
• • • numpy.ndarray.byteswap()
• NumPy 副本和視圖
• • • 無復制
    • 視圖或淺拷貝
    • 副本或深拷貝
  • Python append() 與深拷貝、淺拷貝
  • • 深淺拷貝
• NumPy 矩陣庫(Matrix)
• • • matlib.empty()
    • numpy.matlib.zeros()
    • numpy.matlib.ones()
    • numpy.matlib.eye()
    • numpy.matlib.identity()
    • numpy.matlib.rand()
• NumPy 線性代數
• • • numpy.dot()
    • numpy.vdot()
    • numpy.inner()
    • numpy.matmul
    • numpy.linalg.det()
    • numpy.linalg.solve()
    • numpy.linalg.inv()
• NumPy IO
• • • numpy.save()
    • numpy.savez
    • numpy.savetxt()

NumPy 教程

NumPy(Numerical Python) 是 Python 語言的一個擴展程序庫，支持大量的維度數組與矩陣運算，此外也針對數組運算提供大量的數學函數庫。

NumPy 的前身 Numeric 最早是由 Jim Hugunin 與其它協作者共同開發，2005 年，Travis Oliphant 在 Numeric 中結合了另一個同性質的程序庫 Numarray 的特色，并加入了其它擴展而開發了 NumPy。NumPy 為開放源代碼并且由許多協作者共同維護開發。

NumPy 是一個運行速度非常快的數學庫，主要用于數組計算，包含：

• 一個強大的N維數組對象 ndarray
• 廣播功能函數
• 整合 C/C++/Fortran 代碼的工具
• 線性代數、傅里葉變換、隨機數生成等功能

NumPy Ndarray 對象

NumPy 最重要的一個特點是其 N 維數組對象 ndarray，它是一系列同類型數據的集合，以 0 下標為開始進行集合中元素的索引。

ndarray 對象是用于存放同類型元素的多維數組。

ndarray 中的每個元素在內存中都有相同存儲大小的區域。

ndarray 內部由以下內容組成：

• 一個指向數據（內存或內存映射文件中的一塊數據）的指針。
• 數據類型或 dtype，描述在數組中的固定大小值的格子。
• 一個表示數組形狀（shape）的元組，表示各維度大小的元組。
• 一個跨度元組（stride），其中的整數指的是為了前進到當前維度下一個元素需要"跨過"的字節數。

ndarray 的內部結構:

跨度可以是負數，這樣會使數組在內存中后向移動，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。

創建一個 ndarray 只需調用 NumPy 的 array 函數即可：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

參數說明：

名稱描述

object	數組或嵌套的數列
dtype	數組元素的數據類型，可選
copy	對象是否需要復制，可選
order	創建數組的樣式，C為行方向，F為列方向，A為任意方向（默認）
subok	默認返回一個與基類類型一致的數組
ndmin	指定生成數組的最小維度

ndarray 對象由計算機內存的連續一維部分組成，并結合索引模式，將每個元素映射到內存塊中的一個位置。內存塊以行順序(C樣式)或列順序(FORTRAN或MatLab風格，即前述的F樣式)來保存元素

NumPy 數據類型

numpy 支持的數據類型比 Python 內置的類型要多很多，基本上可以和 C 語言的數據類型對應上，其中部分類型對應為 Python 內置的類型。下表列舉了常用 NumPy 基本類型。

名稱描述

bool_	布爾型數據類型（True 或者 False）
int_	默認的整數類型（類似于 C 語言中的 long，int32 或 int64）
intc	與 C 的 int 類型一樣，一般是 int32 或 int 64
intp	用于索引的整數類型（類似于 C 的 ssize_t，一般情況下仍然是 int32 或 int64）
int8	字節（-128 to 127）
int16	整數（-32768 to 32767）
int32	整數（-2147483648 to 2147483647）
int64	整數（-9223372036854775808 to 9223372036854775807）
uint8	無符號整數（0 to 255）
uint16	無符號整數（0 to 65535）
uint32	無符號整數（0 to 4294967295）
uint64	無符號整數（0 to 18446744073709551615）
float_	float64 類型的簡寫
float16	半精度浮點數，包括：1 個符號位，5 個指數位，10 個尾數位
float32	單精度浮點數，包括：1 個符號位，8 個指數位，23 個尾數位
float64	雙精度浮點數，包括：1 個符號位，11 個指數位，52 個尾數位
complex_	complex128 類型的簡寫，即 128 位復數
complex64	復數，表示雙 32 位浮點數（實數部分和虛數部分）
complex128	復數，表示雙 64 位浮點數（實數部分和虛數部分）

numpy 的數值類型實際上是 dtype 對象的實例，并對應唯一的字符，包括 np.bool_，np.int32，np.float32，等等。

數據類型對象 (dtype)

數據類型對象是用來描述與數組對應的內存區域如何使用，這依賴如下幾個方面：

• 數據的類型（整數，浮點數或者 Python 對象）
• 數據的大小（例如， 整數使用多少個字節存儲）
• 數據的字節順序（小端法或大端法）
• 在結構化類型的情況下，字段的名稱、每個字段的數據類型和每個字段所取的內存塊的部分
• 如果數據類型是子數組，它的形狀和數據類型

字節順序是通過對數據類型預先設定"<“或”>“來決定的。”<“意味著小端法(最小值存儲在最小的地址，即低位組放在最前面)。”>"意味著大端法(最重要的字節存儲在最小的地址，即高位組放在最前面)。

dtype 對象是使用以下語法構造的：

numpy.dtype(object, align, copy)

• object - 要轉換為的數據類型對象
• align - 如果為 true，填充字段使其類似 C 的結構體。
• copy - 復制 dtype 對象 ，如果為 false，則是對內置數據類型對象的引用

每個內建類型都有一個唯一定義它的字符代碼，如下：

字符對應類型

b	布爾型
i	(有符號) 整型
u	無符號整型 integer
f	浮點型
c	復數浮點型
m	timedelta（時間間隔）
M	datetime（日期時間）
O	(Python) 對象
S, a	(byte-)字符串
U	Unicode
V	原始數據 (void)

NumPy 讀取數據

CSV:Comma-Separated Value,逗號分隔值文件

顯示：表格狀態

源文件：換行和逗號分隔行列的格式化文本,每一行的數據表示一條記錄

由于csv便于展示,讀取和寫入,所以很多地方也是用csv的格式存儲和傳輸中小型的數據,為了方便教學,我們會經常操作csv格式的文件,但是操作數據庫中的數據也是很容易的實現的

np.loadtxt(fname,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False) 參數解釋

frame	文件、字符串或產生器，可以是,gz或bz2壓縮文件
dtype	數據類型，可選，CSV的字符串以什么數據類型讀入數據，默認 np.float
delimiter	分隔字符串，默認是任何空格，改為 逗號
skiprows	跳過前x行，一般跳過第一行表頭
usecols	讀取指定的列，索引，元組類型
unpack	如果True，讀入屬性將分別寫入不同數組變量，Flase讀入數據只能寫入一個數組變量，默認Flase

NumPy 數組屬性

NumPy 數組的維數稱為秩（rank），秩就是軸的數量，即數組的維度，一維數組的秩為 1，二維數組的秩為 2，以此類推。

在 NumPy中，每一個線性的數組稱為是一個軸（axis），也就是維度（dimensions）。比如說，二維數組相當于是兩個一維數組，其中第一個一維數組中每個元素又是一個一維數組。所以一維數組就是 NumPy 中的軸（axis），第一個軸相當于是底層數組，第二個軸是底層數組里的數組。而軸的數量——秩，就是數組的維數。

很多時候可以聲明 axis。axis=0，表示沿著第 0 軸進行操作，即對每一列進行操作；axis=1，表示沿著第1軸進行操作，即對每一行進行操作。

NumPy 的數組中比較重要 ndarray 對象屬性有：

屬性說明

ndarray.ndim	秩，即軸的數量或維度的數量
ndarray.shape	數組的維度，對于矩陣，n 行 m 列
ndarray.size	數組元素的總個數，相當于 .shape 中 n*m 的值
ndarray.dtype	ndarray 對象的元素類型
ndarray.itemsize	ndarray 對象中每個元素的大小，以字節為單位
ndarray.flags	ndarray 對象的內存信息
ndarray.real	ndarray元素的實部
ndarray.imag	ndarray 元素的虛部
ndarray.data	包含實際數組元素的緩沖區，由于一般通過數組的索引獲取元素，所以通常不需要使用這個屬性。

ndarray.ndim

ndarray.ndim 用于返回數組的維數，等于秩。

ndarray.shape

ndarray.shape 表示數組的維度，返回一個元組，這個元組的長度就是維度的數目，即 ndim 屬性(秩)。比如，一個二維數組，其維度表示"行數"和"列數"。

ndarray.shape 也可以用于調整數組大小。

NumPy 也提供了 reshape 函數來調整數組大小。

ndarray.itemsize

ndarray.itemsize 以字節的形式返回數組中每一個元素的大小。

例如，一個元素類型為 float64 的數組 itemsiz 屬性值為 8(float64 占用 64 個 bits，每個字節長度為 8，所以 64/8，占用 8 個字節），又如，一個元素類型為 complex32 的數組 item 屬性為 4（32/8）。

ndarray.flags

ndarray.flags 返回 ndarray 對象的內存信息，包含以下屬性：

屬性描述

C_CONTIGUOUS ?	數據是在一個單一的C風格的連續段中
F_CONTIGUOUS (F)	數據是在一個單一的Fortran風格的連續段中
OWNDATA (O)	數組擁有它所使用的內存或從另一個對象中借用它
WRITEABLE (W)	數據區域可以被寫入，將該值設置為 False，則數據為只讀
ALIGNED (A)	數據和所有元素都適當地對齊到硬件上
UPDATEIFCOPY (U)	這個數組是其它數組的一個副本，當這個數組被釋放時，原數組的內容將被更新

NumPy 創建數組

ndarray 數組除了可以使用底層 ndarray 構造器來創建外，也可以通過以下幾種方式來創建。

numpy.empty

numpy.empty 方法用來創建一個指定形狀（shape）、數據類型（dtype）且未初始化的數組：

numpy.empty(shape, dtype = float, order = 'C')

參數說明：

參數描述

shape	數組形狀
dtype	數據類型，可選
order	有"C"和"F"兩個選項,分別代表，行優先和列優先，在計算機內存中的存儲元素的順序。

注意 ? 數組元素為隨機值，因為它們未初始化。

numpy.zeros

創建指定大小的數組，數組元素以 0 來填充：

numpy.zeros(shape, dtype = float, order = 'C')

參數說明：

參數描述

shape	數組形狀
dtype	數據類型，可選
order	‘C’ 用于 C 的行數組，或者 ‘F’ 用于 FORTRAN 的列數組

numpy.ones

創建指定形狀的數組，數組元素以 1 來填充：

numpy.ones(shape, dtype = None, order = 'C')

參數說明：

參數描述

shape	數組形狀
dtype	數據類型，可選
order	‘C’ 用于 C 的行數組，或者 ‘F’ 用于 FORTRAN 的列數組

NumPy 從已有的數組創建數組

numpy.asarray

numpy.asarray 類似 numpy.array，但 numpy.asarray 參數只有三個，比 numpy.array 少兩個。

numpy.asarray(a, dtype = None, order = None)

參數說明：

參數描述

a	任意形式的輸入參數，可以是，列表, 列表的元組, 元組, 元組的元組, 元組的列表，多維數組
dtype	數據類型，可選
order	可選，有"C"和"F"兩個選項,分別代表，行優先和列優先，在計算機內存中的存儲元素的順序。

numpy.frombuffer

numpy.frombuffer 用于實現動態數組。

numpy.frombuffer 接受 buffer 輸入參數，以流的形式讀入轉化成 ndarray 對象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

注意：buffer 是字符串的時候，Python3 默認 str 是 Unicode 類型，所以要轉成 bytestring 在原 str 前加上 b。

參數說明：

參數描述

buffer	可以是任意對象，會以流的形式讀入。
dtype	返回數組的數據類型，可選
count	讀取的數據數量，默認為-1，讀取所有數據。
offset	讀取的起始位置，默認為0。

numpy.fromiter

numpy.fromiter 方法從可迭代對象中建立 ndarray 對象，返回一維數組。

numpy.fromiter(iterable, dtype, count=-1) 參數描述

iterable	可迭代對象
dtype	返回數組的數據類型
count	讀取的數據數量，默認為-1，讀取所有數據

NumPy 從數值范圍創建數組

numpy.arange

numpy 包中的使用 arange 函數創建數值范圍并返回 ndarray 對象，函數格式如下：

numpy.arange(start, stop, step, dtype)

根據 start 與 stop 指定的范圍以及 step 設定的步長，生成一個 ndarray。

參數說明：

參數描述

start	起始值，默認為0
stop	終止值（不包含）
step	步長，默認為1
dtype	返回ndarray的數據類型，如果沒有提供，則會使用輸入數據的類型。

numpy.linspace

numpy.linspace 函數用于創建一個一維數組，數組是一個等差數列構成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

參數說明：

參數描述

start	序列的起始值
stop	序列的終止值，如果endpoint為true，該值包含于數列中
num	要生成的等步長的樣本數量，默認為50
endpoint	該值為 true 時，數列中中包含stop值，反之不包含，默認是True。
retstep	如果為 True 時，生成的數組中會顯示間距，反之不顯示。
dtype	ndarray 的數據類型

numpy.logspace

numpy.logspace 函數用于創建一個于等比數列。格式如下：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

base 參數意思是取對數的時候 log 的下標。

參數描述

start	序列的起始值為：base ** start
stop	序列的終止值為：base ** stop。如果endpoint為true，該值包含于數列中
num	要生成的等步長的樣本數量，默認為50
endpoint	該值為 true 時，數列中中包含stop值，反之不包含，默認是True。
base	對數 log 的底數。
dtype	ndarray 的數據類型

NumPy 切片和索引

ndarray對象的內容可以通過索引或切片來訪問和修改，與 Python 中 list 的切片操作一樣。

ndarray 數組可以基于 0 - n 的下標進行索引，切片對象可以通過內置的 slice 函數，并設置 start, stop 及 step 參數進行，從原數組中切割出一個新數組。通過冒號分隔切片參數 start:stop:step 來進行切片操作。

冒號 : 的解釋：如果只放置一個參數，如 [2]，將返回與該索引相對應的單個元素。如果為 [2:]，表示從該索引開始以后的所有項都將被提取。如果使用了兩個參數，如 [2:7]，那么則提取兩個索引(不包括停止索引)之間的項。

切片還可以包括省略號 …，來使選擇元組的長度與數組的維度相同。 如果在行位置使用省略號，它將返回包含行中元素的 ndarray。

NumPy 高級索引

NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整數和切片的索引外，數組可以由整數數組索引、布爾索引及花式索引。

布爾索引

我們可以通過一個布爾數組來索引目標數組。

布爾索引通過布爾運算（如：比較運算符）來獲取符合指定條件的元素的數組。

~（取補運算符）來過濾 NaN

花式索引

花式索引指的是利用整數數組進行索引。

花式索引根據索引數組的值作為目標數組的某個軸的下標來取值。對于使用一維整型數組作為索引，如果目標是一維數組，那么索引的結果就是對應位置的元素；如果目標是二維數組，那么就是對應下標的行。

花式索引跟切片不一樣，它總是將數據復制到新數組中。

傳入順序索引數組

實例

import numpy as npx=np.arange(32).reshape((8,4)) print (x[[4,2,1,7]])

輸出結果為：

[[16 17 18 19][ 8 9 10 11][ 4 5 6 7][28 29 30 31]]

傳入倒序索引數組

實例

import numpy as npx=np.arange(32).reshape((8,4)) print (x[[-4,-2,-1,-7]])

輸出結果為：

[[16 17 18 19][24 25 26 27][28 29 30 31][ 4 5 6 7]]

傳入多個索引數組（要使用np.ix_）

實例

import numpy as npx=np.arange(32).reshape((8,4)) print (x[np.ix_([1,5,7,2],[0,3,1,2])])

輸出結果為：

[[ 4 7 5 6][20 23 21 22][28 31 29 30][ 8 11 9 10]]

NumPy 廣播(Broadcast)

廣播(Broadcast)是 numpy 對不同形狀(shape)的數組進行數值計算的方式， 對數組的算術運算通常在相應的元素上進行。

如果兩個數組 a 和 b 形狀相同，即滿足 a.shape == b.shape，那么 a*b 的結果就是 a 與 b 數組對應位相乘。這要求維數相同，且各維度的長度相同。

當運算中的 2 個數組的形狀不同時，numpy 將自動觸發廣播機制。如：

實例

import numpy as npa = np.array([[ 0, 0, 0],[10,10,10],[20,20,20],[30,30,30]]) b = np.array([1,2,3]) print(a + b)

輸出結果為：

[[ 1 2 3][11 12 13][21 22 23][31 32 33]]

下面的圖片展示了數組 b 如何通過廣播來與數組 a 兼容。

4x3 的二維數組與長為 3 的一維數組相加，等效于把數組 b 在二維上重復 4 次再運算

廣播的規則:

• 讓所有輸入數組都向其中形狀最長的數組看齊，形狀中不足的部分都通過在前面加 1 補齊。
• 輸出數組的形狀是輸入數組形狀的各個維度上的最大值。
• 如果輸入數組的某個維度和輸出數組的對應維度的長度相同或者其長度為 1 時，這個數組能夠用來計算，否則出錯。
• 當輸入數組的某個維度的長度為 1 時，沿著此維度運算時都用此維度上的第一組值。

**簡單理解：**對兩個數組，分別比較他們的每一個維度（若其中一個數組沒有當前維度則忽略），滿足：

• 數組擁有相同形狀。
• 當前維度的值相等。
• 當前維度的值有一個是 1。

若條件不滿足，拋出 “ValueError: frames are not aligned” 異常。

NumPy 迭代數組

NumPy 迭代器對象 numpy.nditer 提供了一種靈活訪問一個或者多個數組元素的方式。

迭代器最基本的任務的可以完成對數組元素的訪問。

控制遍歷順序

• for x in np.nditer(a, order='F'):Fortran order，即是列序優先；
• for x in np.nditer(a.T, order='C'):C order，即是行序優先；

可以通過顯式設置，來強制 nditer 對象使用某種順序。

修改數組中元素的值

nditer 對象有另一個可選參數 op_flags。 默認情況下，nditer 將視待迭代遍歷的數組為只讀對象（read-only），為了在遍歷數組的同時，實現對數組元素值得修改，必須指定 read-write 或者 write-only 的模式。

使用外部循環

nditer類的構造器擁有flags參數，它可以接受下列值：

參數描述

c_index	可以跟蹤 C 順序的索引
f_index	可以跟蹤 Fortran 順序的索引
multi-index	每次迭代可以跟蹤一種索引類型
external_loop	給出的值是具有多個值的一維數組，而不是零維數組

廣播迭代

如果兩個數組是可廣播的，nditer 組合對象能夠同時迭代它們。 假設數組 a 的維度為 3X4，數組 b 的維度為 1X4 ，則使用以下迭代器（數組 b 被廣播到 a 的大小）。

Numpy 數組操作

Numpy 中包含了一些函數用于處理數組，大概可分為以下幾類：

• 修改數組形狀
• 翻轉數組
• 修改數組維度
• 連接數組
• 分割數組
• 數組元素的添加與刪除

修改數組形狀

函數描述

reshape	不改變數據的條件下修改形狀
flat	數組元素迭代器
flatten	返回一份數組拷貝，對拷貝所做的修改不會影響原始數組
ravel	返回展開數組

numpy.reshape

numpy.reshape 函數可以在不改變數據的條件下修改形狀，格式如下： numpy.reshape(arr, newshape, order=‘C’)

• arr：要修改形狀的數組
• newshape：整數或者整數數組，新的形狀應當兼容原有形狀
• order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原順序，‘k’ – 元素在內存中的出現順序。

numpy.ndarray.flat

numpy.ndarray.flat 是一個數組元素迭代器。

numpy.ndarray.flatten

numpy.ndarray.flatten 返回一份數組拷貝，對拷貝所做的修改不會影響原始數組，格式如下：

ndarray.flatten(order='C')

參數說明：

• order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原順序，‘K’ – 元素在內存中的出現順序。

numpy.ravel

numpy.ravel() 展平的數組元素，順序通常是"C風格"，返回的是數組視圖（view，有點類似 C/C++引用reference的意味），修改會影響原始數組。

該函數接收兩個參數：

numpy.ravel(a, order='C')

參數說明：

• order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原順序，‘K’ – 元素在內存中的出現順序。

翻轉數組

函數描述

transpose	對換數組的維度
ndarray.T	和 self.transpose() 相同
rollaxis	向后滾動指定的軸
swapaxes	對換數組的兩個軸

numpy.transpose

numpy.transpose 函數用于對換數組的維度，格式如下：

numpy.transpose(arr, axes)

參數說明:

• arr：要操作的數組
• axes：整數列表，對應維度，通常所有維度都會對換。

numpy.rollaxis

numpy.rollaxis 函數向后滾動特定的軸到一個特定位置，格式如下：

numpy.rollaxis(arr, axis, start)

參數說明：

• arr：數組
• axis：要向后滾動的軸，其它軸的相對位置不會改變
• start：默認為零，表示完整的滾動。會滾動到特定位置。

numpy.swapaxes

numpy.swapaxes 函數用于交換數組的兩個軸，格式如下：

numpy.swapaxes(arr, axis1, axis2)

• arr：輸入的數組
• axis1：對應第一個軸的整數
• axis2：對應第二個軸的整數

修改數組維度

維度描述

broadcast	產生模仿廣播的對象
broadcast_to	將數組廣播到新形狀
expand_dims	擴展數組的形狀
squeeze	從數組的形狀中刪除一維條目

numpy.broadcast

numpy.broadcast 用于模仿廣播的對象，它返回一個對象，該對象封裝了將一個數組廣播到另一個數組的結果。

numpy.broadcast_to

numpy.broadcast_to 函數將數組廣播到新形狀。它在原始數組上返回只讀視圖。 它通常不連續。 如果新形狀不符合 NumPy 的廣播規則，該函數可能會拋出ValueError。

numpy.broadcast_to(array, shape, subok)

numpy.expand_dims

numpy.expand_dims 函數通過在指定位置插入新的軸來擴展數組形狀，函數格式如下:

numpy.expand_dims(arr, axis)

參數說明：

• arr：輸入數組
• axis：新軸插入的位置

numpy.squeeze

numpy.squeeze 函數從給定數組的形狀中刪除一維的條目，函數格式如下：

numpy.squeeze(arr, axis)

參數說明：

• arr：輸入數組
• axis：整數或整數元組，用于選擇形狀中一維條目的子集

連接數組

函數描述

concatenate	連接沿現有軸的數組序列
stack	沿著新的軸加入一系列數組。
hstack	水平堆疊序列中的數組（列方向）
vstack	豎直堆疊序列中的數組（行方向）

numpy.concatenate

numpy.concatenate 函數用于沿指定軸連接相同形狀的兩個或多個數組，格式如下：

numpy.concatenate((a1, a2, ...), axis)

參數說明：

• a1, a2, ...：相同類型的數組
• axis：沿著它連接數組的軸，默認為 0

numpy.stack

numpy.stack 函數用于沿新軸連接數組序列，格式如下：

numpy.stack(arrays, axis)

參數說明：

• arrays相同形狀的數組序列
• axis：返回數組中的軸，輸入數組沿著它來堆疊

numpy.hstack

numpy.hstack 是 numpy.stack 函數的變體，它通過水平堆疊來生成數組。

numpy.vstack

numpy.vstack 是 numpy.stack 函數的變體，它通過垂直堆疊來生成數組。

分割數組

函數數組及操作

split	將一個數組分割為多個子數組
hsplit	將一個數組水平分割為多個子數組（按列）
vsplit	將一個數組垂直分割為多個子數組（按行）

numpy.split

numpy.split 函數沿特定的軸將數組分割為子數組，格式如下：

numpy.split(ary, indices_or_sections, axis)

參數說明：

• ary：被分割的數組
• indices_or_sections：果是一個整數，就用該數平均切分，如果是一個數組，為沿軸切分的位置（左開右閉）
• axis：沿著哪個維度進行切向，默認為0，橫向切分。為1時，縱向切分

numpy.hsplit

numpy.hsplit 函數用于水平分割數組，通過指定要返回的相同形狀的數組數量來拆分原數組。

numpy.vsplit

numpy.vsplit 沿著垂直軸分割，其分割方式與hsplit用法相同。

數組元素的添加與刪除

函數元素及描述

resize	返回指定形狀的新數組
append	將值添加到數組末尾
insert	沿指定軸將值插入到指定下標之前
delete	刪掉某個軸的子數組，并返回刪除后的新數組
unique	查找數組內的唯一元素

numpy.resize

numpy.resize 函數返回指定大小的新數組。

如果新數組大小大于原始大小，則包含原始數組中的元素的副本。

numpy.resize(arr, shape)

參數說明：

• arr：要修改大小的數組
• shape：返回數組的新形狀

numpy.append

numpy.append 函數在數組的末尾添加值。 追加操作會分配整個數組，并把原來的數組復制到新數組中。 此外，輸入數組的維度必須匹配否則將生成ValueError。

append 函數返回的始終是一個一維數組。

numpy.append(arr, values, axis=None)

參數說明：

• arr：輸入數組
• values：要向arr添加的值，需要和arr形狀相同（除了要添加的軸）
• axis：默認為 None。當axis無定義時，是橫向加成，返回總是為一維數組！當axis有定義的時候，分別為0和1的時候。當axis有定義的時候，分別為0和1的時候（列數要相同）。當axis為1時，數組是加在右邊（行數要相同）。

numpy.insert

numpy.insert 函數在給定索引之前，沿給定軸在輸入數組中插入值。

如果值的類型轉換為要插入，則它與輸入數組不同。 插入沒有原地的，函數會返回一個新數組。 此外，如果未提供軸，則輸入數組會被展開。

numpy.insert(arr, obj, values, axis)

參數說明：

• arr：輸入數組
• obj：在其之前插入值的索引
• values：要插入的值
• axis：沿著它插入的軸，如果未提供，則輸入數組會被展開

numpy.delete

numpy.delete 函數返回從輸入數組中刪除指定子數組的新數組。 與 insert() 函數的情況一樣，如果未提供軸參數，則輸入數組將展開。

Numpy.delete(arr, obj, axis)

參數說明：

• arr：輸入數組
• obj：可以被切片，整數或者整數數組，表明要從輸入數組刪除的子數組
• axis：沿著它刪除給定子數組的軸，如果未提供，則輸入數組會被展開

numpy.unique

numpy.unique 函數用于去除數組中的重復元素。

numpy.unique(arr, return_index, return_inverse, return_counts)

• arr：輸入數組，如果不是一維數組則會展開
• return_index：如果為true，返回新列表元素在舊列表中的位置（下標），并以列表形式儲
• return_inverse：如果為true，返回舊列表元素在新列表中的位置（下標），并以列表形式儲
• return_counts：如果為true，返回去重數組中的元素在原數組中的出現次數

NumPy 位運算

NumPy “bitwise_” 開頭的函數是位運算函數。

NumPy 位運算包括以下幾個函數：

函數描述

bitwise_and	對數組元素執行位與操作
bitwise_or	對數組元素執行位或操作
invert	按位取反
left_shift	向左移動二進制表示的位
right_shift	向右移動二進制表示的位

**注：**也可以使用 “&”、 “~”、 “|” 和 “^” 等操作符進行計算。

bitwise_and

bitwise_and() 函數對數組中整數的二進制形式執行位與運算。

位與操作運算規律如下：

ABAND

1	1	1
1	0	0
0	1	0
0	0	0

bitwise_or

bitwise_or()函數對數組中整數的二進制形式執行位或運算。

位或操作運算規律如下：

ABOR

1	1	1
1	0	1
0	1	1
0	0	0

invert

invert() 函數對數組中整數進行位取反運算，即 0 變成 1，1 變成 0。

對于有符號整數，取該二進制數的補碼，然后 +1。二進制數，最高位為0表示正數，最高位為 1 表示負數。

看看 ~1 的計算步驟：

• 將1(這里叫：原碼)轉二進制 ＝ 00000001

• 按位取反 ＝ 11111110

• 發現符號位(即最高位)為1(表示負數)，將除符號位之外的其他數字取反 ＝ 10000001

• 末位加1取其補碼 ＝ 10000010

• 轉換回十進制 ＝ -2

• 表達式二進制值（2 的補數）十進制值

  5	00000000 00000000 00000000 0000010	5
  ~5	11111111 11111111 11111111 11111010	-6

left_shift

left_shift() 函數將數組元素的二進制形式向左移動到指定位置，右側附加相等數量的 0。

right_shift

right_shift() 函數將數組元素的二進制形式向右移動到指定位置，左側附加相等數量的 0。

NumPy 字符串函數

以下函數用于對 dtype 為 numpy.string_ 或 numpy.unicode_ 的數組執行向量化字符串操作。 它們基于 Python 內置庫中的標準字符串函數。

這些函數在字符數組類（numpy.char）中定義。

函數描述

add()	對兩個數組的逐個字符串元素進行連接
multiply()	返回按元素多重連接后的字符串
center()	居中字符串
capitalize()	將字符串第一個字母轉換為大寫
title()	將字符串的每個單詞的第一個字母轉換為大寫
lower()	數組元素轉換為小寫
upper()	數組元素轉換為大寫
split()	指定分隔符對字符串進行分割，并返回數組列表
splitlines()	返回元素中的行列表，以換行符分割
strip()	移除元素開頭或者結尾處的特定字符
join()	通過指定分隔符來連接數組中的元素
replace()	使用新字符串替換字符串中的所有子字符串
decode()	數組元素依次調用str.decode
encode()	數組元素依次調用str.encode

numpy.char.add()

numpy.char.add() 函數依次對兩個數組的元素進行字符串連接。

numpy.char.multiply()

numpy.char.multiply() 函數執行多重連接。

numpy.char.center()

numpy.char.center() 函數用于將字符串居中，并使用指定字符在左側和右側進行填充。

numpy.char.capitalize()

numpy.char.capitalize() 函數將字符串的第一個字母轉換為大寫。

numpy.char.title()

numpy.char.title() 函數將字符串的每個單詞的第一個字母轉換為大寫。

numpy.char.lower()

numpy.char.lower() 函數對數組的每個元素轉換為小寫。它對每個元素調用 str.lower。

numpy.char.upper()

numpy.char.upper() 函數對數組的每個元素轉換為大寫。它對每個元素調用 str.upper。

numpy.char.split()

numpy.char.split() 通過指定分隔符對字符串進行分割，并返回數組。默認情況下，分隔符為空格。

numpy.char.splitlines()

numpy.char.splitlines() 函數以換行符作為分隔符來分割字符串，并返回數組。

\n，\r，\r\n 都可用作換行符。

numpy.char.strip()

numpy.char.strip() 函數用于移除開頭或結尾處的特定字符。

numpy.char.join()

numpy.char.join() 函數通過指定分隔符來連接數組中的元素或字符串。

numpy.char.replace()

numpy.char.replace() 函數使用新字符串替換字符串中的所有子字符串。

numpy.char.encode()

numpy.char.encode() 函數對數組中的每個元素調用 str.encode 函數。 默認編碼是 utf-8，可以使用標準 Python 庫中的編解碼器。

numpy.char.decode()

numpy.char.decode() 函數對編碼的元素進行 str.decode() 解碼。

NumPy 數學函數

NumPy 包含大量的各種數學運算的函數，包括三角函數，算術運算的函數，復數處理函數等。

三角函數

NumPy 提供了標準的三角函數：sin()、cos()、tan()。

arcsin，arccos，和 arctan 函數返回給定角度的 sin，cos 和 tan 的反三角函數。

這些函數的結果可以通過 numpy.degrees() 函數將弧度轉換為角度。

舍入函數

numpy.around() 函數返回指定數字的四舍五入值。

numpy.around(a,decimals)

參數說明：

• a: 數組
• decimals: 舍入的小數位數。 默認值為0。 如果為負，整數將四舍五入到小數點左側的位置

numpy.floor()

numpy.floor() 返回小于或者等于指定表達式的最大整數，即向下取整。

numpy.ceil()

numpy.ceil() 返回大于或者等于指定表達式的最小整數，即向上取整。

NumPy 算術函數

NumPy 算術函數包含簡單的加減乘除: add()，subtract()，multiply() 和 divide()。

需要注意的是數組必須具有相同的形狀或符合數組廣播規則。

此外 Numpy 也包含了其他重要的算術函數。

numpy.reciprocal()

numpy.reciprocal() 函數返回參數逐元素的倒數。如 1/4 倒數為 4/1。

numpy.power()

numpy.power() 函數將第一個輸入數組中的元素作為底數，計算它與第二個輸入數組中相應元素的冪。

numpy.mod()

numpy.mod() 計算輸入數組中相應元素的相除后的余數。 函數 numpy.remainder() 也產生相同的結果。

NumPy 統計函數

NumPy 提供了很多統計函數，用于從數組中查找最小元素，最大元素，百分位標準差和方差等。 函數說明如下：

numpy.amin() 和 numpy.amax()

numpy.amin() 用于計算數組中的元素沿指定軸的最小值。

numpy.amax() 用于計算數組中的元素沿指定軸的最大值。

numpy.ptp()

numpy.ptp()函數計算數組中元素最大值與最小值的差（最大值 - 最小值）。

numpy.percentile()

百分位數是統計中使用的度量，表示小于這個值的觀察值的百分比。 函數numpy.percentile()接受以下參數。

numpy.percentile(a, q, axis)

參數說明：

• a: 輸入數組
• q: 要計算的百分位數，在 0 ~ 100 之間
• axis: 沿著它計算百分位數的軸

首先明確百分位數：

第 p 個百分位數是這樣一個值，它使得至少有 p% 的數據項小于或等于這個值，且至少有 (100-p)% 的數據項大于或等于這個值。

舉個例子：高等院校的入學考試成績經常以百分位數的形式報告。比如，假設某個考生在入學考試中的語文部分的原始分數為 54 分。相對于參加同一考試的其他學生來說，他的成績如何并不容易知道。但是如果原始分數54分恰好對應的是第70百分位數，我們就能知道大約70%的學生的考分比他低，而約30%的學生考分比他高。這里的 p = 70。

numpy.median()

numpy.median() 函數用于計算數組 a 中元素的中位數（中值）

numpy.mean()

numpy.mean() 函數返回數組中元素的算術平均值。 如果提供了軸，則沿其計算。

算術平均值是沿軸的元素的總和除以元素的數量。

numpy.average()

numpy.average() 函數根據在另一個數組中給出的各自的權重計算數組中元素的加權平均值。

該函數可以接受一個軸參數。 如果沒有指定軸，則數組會被展開。

加權平均值即將各數值乘以相應的權數，然后加總求和得到總體值，再除以總的單位數。

考慮數組[1,2,3,4]和相應的權重[4,3,2,1]，通過將相應元素的乘積相加，并將和除以權重的和，來計算加權平均值。

加權平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)

標準差

標準差是一組數據平均值分散程度的一種度量。

標準差是方差的算術平方根。

標準差公式如下：

std = sqrt(mean((x - x.mean())**2))

如果數組是 [1，2，3，4]，則其平均值為 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且其平均值的平方根除以 4，即 sqrt(5/4) ，結果為 1.1180339887498949。

方差

統計中的方差（樣本方差）是每個樣本值與全體樣本值的平均數之差的平方值的平均數，即 mean((x - x.mean())** 2)。

換句話說，標準差是方差的平方根。

NumPy 排序、條件刷選函數

NumPy 提供了多種排序的方法。 這些排序函數實現不同的排序算法，每個排序算法的特征在于執行速度，最壞情況性能，所需的工作空間和算法的穩定性。 下表顯示了三種排序算法的比較。

種類速度最壞情況工作空間穩定性

'quicksort'（快速排序）	1	O(n^2)	0	否
'mergesort'（歸并排序）	2	O(n*log(n))	~n/2	是
'heapsort'（堆排序）	3	O(n*log(n))	0	否

numpy.sort()

numpy.sort() 函數返回輸入數組的排序副本。函數格式如下：

numpy.sort(a, axis, kind, order)

參數說明：

• a: 要排序的數組
• axis: 沿著它排序數組的軸，如果沒有數組會被展開，沿著最后的軸排序， axis=0 按列排序，axis=1 按行排序
• kind: 默認為’quicksort’（快速排序）
• order: 如果數組包含字段，則是要排序的字段

numpy.argsort()

numpy.argsort() 函數返回的是數組值從小到大的索引值。

numpy.lexsort()

numpy.lexsort() 用于對多個序列進行排序。把它想象成對電子表格進行排序，每一列代表一個序列，排序時優先照顧靠后的列。

這里舉一個應用場景：小升初考試，重點班錄取學生按照總成績錄取。在總成績相同時，數學成績高的優先錄取，在總成績和數學成績都相同時，按照英語成績錄取…… 這里，總成績排在電子表格的最后一列，數學成績在倒數第二列，英語成績在倒數第三列。

msort、sort_complex、partition、argpartition

函數描述

msort(a)	數組按第一個軸排序，返回排序后的數組副本。np.msort(a) 相等于 np.sort(a, axis=0)。
sort_complex(a)	對復數按照先實部后虛部的順序進行排序。
partition(a, kth[, axis, kind, order])	指定一個數，對數組進行分區
argpartition(a, kth[, axis, kind, order])	可以通過關鍵字 kind 指定算法沿著指定軸對數組進行分區

numpy.argmax() 和 numpy.argmin()

numpy.argmax() 和 numpy.argmin()函數分別沿給定軸返回最大和最小元素的索引。

numpy.nonzero()

numpy.nonzero() 函數返回輸入數組中非零元素的索引。

numpy.where()

numpy.where() 函數返回輸入數組中滿足給定條件的元素的索引。

numpy.extract()

numpy.extract() 函數根據某個條件從數組中抽取元素，返回滿條件的元素。

NumPy 字節交換

在幾乎所有的機器上，多字節對象都被存儲為連續的字節序列。字節順序，是跨越多字節的程序對象的存儲規則。

• **大端模式：**指數據的高字節保存在內存的低地址中，而數據的低字節保存在內存的高地址中，這樣的存儲模式有點兒類似于把數據當作字符串順序處理：地址由小向大增加，而數據從高位往低位放；這和我們的閱讀習慣一致。
• **小端模式：**指數據的高字節保存在內存的高地址中，而數據的低字節保存在內存的低地址中，這種存儲模式將地址的高低和數據位權有效地結合起來，高地址部分權值高，低地址部分權值低。

例如在 C 語言中，一個類型為 int 的變量 x 地址為 0x100，那么其對應地址表達式&x的值為 0x100。且x的四個字節將被存儲在存儲器的 0x100, 0x101, 0x102, 0x103位置。

numpy.ndarray.byteswap()

numpy.ndarray.byteswap() 函數將 ndarray 中每個元素中的字節進行大小端轉換。

NumPy 副本和視圖

副本是一個數據的完整的拷貝，如果我們對副本進行修改，它不會影響到原始數據，物理內存不在同一位置。

視圖是數據的一個別稱或引用，通過該別稱或引用亦便可訪問、操作原有數據，但原有數據不會產生拷貝。如果我們對視圖進行修改，它會影響到原始數據，物理內存在同一位置。

視圖一般發生在：

• 1、numpy 的切片操作返回原數據的視圖。
• 2、調用 ndarray 的 view() 函數產生一個視圖。

副本一般發生在：

• Python 序列的切片操作，調用deepCopy()函數。
• 調用 ndarray 的 copy() 函數產生一個副本。

無復制

簡單的賦值不會創建數組對象的副本。 相反，它使用原始數組的相同id()來訪問它。 id()返回 Python 對象的通用標識符，類似于 C 中的指針。

此外，一個數組的任何變化都反映在另一個數組上。 例如，一個數組的形狀改變也會改變另一個數組的形狀。

視圖或淺拷貝

ndarray.view() 方會創建一個新的數組對象，該方法創建的新數組的維數更改不會更改原始數據的維數。使用切片創建視圖修改數據會影響到原始數組。

副本或深拷貝

ndarray.copy() 函數創建一個副本。 對副本數據進行修改，不會影響到原始數據，它們物理內存不在同一位置。

Python append() 與深拷貝、淺拷貝

深淺拷貝

在 Python 中，對象賦值實際上是對象的引用。當創建一個對象，然后把它賦給另一個變量的時候，Python 并沒有拷貝這個對象，而只是拷貝了這個對象的引用，我們稱之為淺拷貝。

在 Python 中，為了使當進行賦值操作時，兩個變量互補影響，可以使用 copy 模塊中的 deepcopy 方法，稱之為深拷貝。

append() 函數

當 list 類型的對象進行 append 操作時，實際上追加的是該對象的引用。

id() 函數：返回對象的唯一標識，可以類比成該對象在內存中的地址。

>>>alist = [] >>> num = [2] >>> alist.append( num ) >>> id( num ) == id( alist[0] ) True

如上例所示，當 num 發生變化時(前提是 id(num) 不發生變化），alist 的內容隨之會發生變化。往往會帶來意想不到的后果，想避免這種情況，可以采用深拷貝解決：

alist.append( copy.deepcopy( num ) )

PS：
id()函數：返回對象的唯一標識，可以類比成該對象在內存中的地址。

NumPy 矩陣庫(Matrix)

NumPy 中包含了一個矩陣庫 numpy.matlib，該模塊中的函數返回的是一個矩陣，而不是 ndarray 對象。

一個$m\times n$ 的矩陣是一個由 $ m $ 行（row）列 $ n $（column）元素排列成的矩形陣列。

矩陣里的元素可以是數字、符號或數學式。

matlib.empty()

matlib.empty() 函數返回一個新的矩陣，語法格式為：

numpy.matlib.empty(shape, dtype, order)

參數說明：

• shape: 定義新矩陣形狀的整數或整數元組
• Dtype: 可選，數據類型
• order: C（行序優先） 或者 F（列序優先）

numpy.matlib.zeros()

numpy.matlib.zeros() 函數創建一個以 0 填充的矩陣。

numpy.matlib.ones()

numpy.matlib.ones()函數創建一個以 1 填充的矩陣。

numpy.matlib.eye()

numpy.matlib.eye() 函數返回一個矩陣，對角線元素為 1，其他位置為零。

numpy.matlib.eye(n, M,k, dtype)

參數說明：

• n: 返回矩陣的行數
• M: 返回矩陣的列數，默認為 n
• k: 對角線的索引
• dtype: 數據類型

numpy.matlib.identity()

numpy.matlib.identity() 函數返回給定大小的單位矩陣。

單位矩陣是個方陣，從左上角到右下角的對角線（稱為主對角線）上的元素均為 1，除此以外全都為 0。

numpy.matlib.rand()

numpy.matlib.rand() 函數創建一個給定大小的矩陣，數據是隨機填充的。

NumPy 線性代數

NumPy 提供了線性代數函數庫 linalg，該庫包含了線性代數所需的所有功能，可以看看下面的說明：

函數描述

dot	兩個數組的點積，即元素對應相乘。
vdot	兩個向量的點積
inner	兩個數組的內積
matmul	兩個數組的矩陣積
determinant	數組的行列式
solve	求解線性矩陣方程
inv	計算矩陣的乘法逆矩陣

numpy.dot()

numpy.dot() 對于兩個一維的數組，計算的是這兩個數組對應下標元素的乘積和(數學上稱之為內積)；對于二維數組，計算的是兩個數組的矩陣乘積；對于多維數組，它的通用計算公式如下，即結果數組中的每個元素都是：數組a的最后一維上的所有元素與數組b的倒數第二位上的所有元素的乘積和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。

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

參數說明：

• a : ndarray 數組
• b : ndarray 數組
• out : ndarray, 可選，用來保存dot()的計算結果

numpy.vdot()

numpy.vdot() 函數是兩個向量的點積。 如果第一個參數是復數，那么它的共軛復數會用于計算。 如果參數是多維數組，它會被展開。

numpy.inner()

numpy.inner() 函數返回一維數組的向量內積。對于更高的維度，它返回最后一個軸上的和的乘積。

numpy.matmul

numpy.matmul 函數返回兩個數組的矩陣乘積。 雖然它返回二維數組的正常乘積，但如果任一參數的維數大于2，則將其視為存在于最后兩個索引的矩陣的棧，并進行相應廣播。

另一方面，如果任一參數是一維數組，則通過在其維度上附加 1 來將其提升為矩陣，并在乘法之后被去除。

numpy.linalg.det()

numpy.linalg.det() 函數計算輸入矩陣的行列式。

行列式在線性代數中是非常有用的值。 它從方陣的對角元素計算。 對于 2×2 矩陣，它是左上和右下元素的乘積與其他兩個的乘積的差。

換句話說，對于矩陣[[a，b]，[c，d]]，行列式計算為 ad-bc。 較大的方陣被認為是 2×2 矩陣的組合。

numpy.linalg.solve()

numpy.linalg.solve() 函數給出了矩陣形式的線性方程的解。

考慮以下線性方程：

x + y + z = 62y + 5z = -42x + 5y - z = 27

可以使用矩陣表示為：

如果矩陣成為A、X和B，方程變為：

AX = B或X = A^(-1)B

numpy.linalg.inv()

numpy.linalg.inv() 函數計算矩陣的乘法逆矩陣。

逆矩陣（inverse matrix）：設A是數域上的一個n階矩陣，若在相同數域上存在另一個n階矩陣B，使得： AB=BA=E ，則我們稱B是A的逆矩陣，而A則被稱為可逆矩陣。注：E為單位矩陣。

NumPy IO

Numpy 可以讀寫磁盤上的文本數據或二進制數據。

NumPy 為 ndarray 對象引入了一個簡單的文件格式：npy。

npy 文件用于存儲重建 ndarray 所需的數據、圖形、dtype 和其他信息。

常用的 IO 函數有：

• load() 和 save() 函數是讀寫文件數組數據的兩個主要函數，默認情況下，數組是以未壓縮的原始二進制格式保存在擴展名為 .npy 的文件中。

• savze() 函數用于將多個數組寫入文件，默認情況下，數組是以未壓縮的原始二進制格式保存在擴展名為 .npz 的文件中。

• loadtxt() 和 savetxt() 函數處理正常的文本文件(.txt 等)

numpy.save()

numpy.save() 函數將數組保存到以 .npy 為擴展名的文件中。

numpy.save(file, arr, allow_pickle=True, fix_imports=True)

參數說明：

• file：要保存的文件，擴展名為 .npy，如果文件路徑末尾沒有擴展名 .npy，該擴展名會被自動加上。
• arr: 要保存的數組
• allow_pickle: 可選，布爾值，允許使用 Python pickles 保存對象數組，Python 中的 pickle 用于在保存到磁盤文件或從磁盤文件讀取之前，對對象進行序列化和反序列化。
• fix_imports: 可選，為了方便 Pyhton2 中讀取 Python3 保存的數據。

.npy是 Numpy 專用的二進制格式后的數據，可以使用 load() 函數來讀取數據就可以正常顯示。

numpy.savez

numpy.savez() 函數將多個數組保存到以 npz 為擴展名的文件中。

numpy.savez(file, *args, **kwds)

參數說明：

• file：要保存的文件，擴展名為 .npz，如果文件路徑末尾沒有擴展名 .npz，該擴展名會被自動加上。
• args: 要保存的數組，可以使用關鍵字參數為數組起一個名字，非關鍵字參數傳遞的數組會自動起名為 arr_0, arr_1, …　。
• kwds: 要保存的數組使用關鍵字名稱。

numpy.savetxt()

savetxt() 函數是以簡單的文本文件格式存儲數據，對應的使用 loadtxt() 函數來獲取數據。

np.loadtxt(FILENAME, dtype=int, delimiter=' ') np.savetxt(FILENAME, a, fmt="%d", delimiter=",")

參數 delimiter 可以指定各種分隔符、針對特定列的轉換器函數、需要跳過的行數等。

總結

以上是生活随笔為你收集整理的NumPy 笔记（超级全！收藏√）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。