Python 数据分析三剑客之 NumPy（一）：理解 NumPy / 数组基础
CSDN 課程推薦：《Python 數據分析與挖掘》，講師劉順祥，浙江工商大學統計學碩士，數據分析師，曾擔任唯品會大數據部擔任數據分析師一職，負責支付環節的數據分析業務。曾與聯想、亨氏、網魚網咖等企業合作多個企業級項目。
NumPy 系列文章：
- Python 數據分析三劍客之 NumPy（一）：理解 NumPy / 數組基礎
- Python 數據分析三劍客之 NumPy（二）：數組索引 / 切片 / 廣播 / 拼接 / 分割
- Python 數據分析三劍客之 NumPy（三）：數組的迭代與位運算
- Python 數據分析三劍客之 NumPy（四）：字符串函數總結與對比
- Python 數據分析三劍客之 NumPy（五）：數學 / 算術 / 統計 / 排序 / 條件 / 判斷函數合集
- Python 數據分析三劍客之 NumPy（六）：矩陣 / 線性代數庫與 IO 操作
另有 Pandas、Matplotlib 系列文章已更新完畢，歡迎關注：
- Pandas 系列文章：https://itrhx.blog.csdn.net/category_9780397.html
- Matplotlib 系列文章：https://itrhx.blog.csdn.net/category_9780418.html
推薦學習資料與網站（博主參與部分文檔翻譯）：
- NumPy 官方中文網：https://www.numpy.org.cn/
- Pandas 官方中文網：https://www.pypandas.cn/
- Matplotlib 官方中文網：https://www.matplotlib.org.cn/
- NumPy、Matplotlib、Pandas 速查表：https://github.com/TRHX/Python-quick-reference-table
文章目錄
- 【1x00】了解 NumPy
- 【2x00】NumPy 數組與 Python 列表的區別
- 【3x00】理解 NumPy Ndarray 對象
- 【4x00】理解不同維度的數組
- 【5x00】創建 Ndarray 對象（創建數組）
- 【5x01】一張表快速了解創建數組的不同方法
- 【5x02】numpy.array()
- 【5x03】numpy.asarray()
- 【5x04】numpy.arange()
- 【5x05】numpy.linspace()
- 【5x06】numpy.logspace()
- 【5x07】numpy.empty()
- 【5x08】numpy.zeros()
- 【5x09】numpy.ones()
- 【5x10】numpy.eye()
- 【5x11】numpy.frombuffer()
- 【5x12】numpy.fromiter()
- 【6x00】改變數組的維度或者形狀
- 【6x01】numpy.reshape()
- 【6x02】numpy.ravel()
- 【6x03】numpy.resize()
- 【6x04】numpy.ndarray.flatten()
- 【6x05】numpy.ndarray.shape
- 【6x06】numpy.ndarray.transpose() & numpy.ndarray.T
- 【6x07】numpy.swapaxes()
- 【7x00】NumPy 數據類型
- 【8x00】NumPy 數組屬性
這里是一段防爬蟲文本，請讀者忽略。 本文原創首發于 CSDN，作者 TRHX。 博客首頁：https://itrhx.blog.csdn.net/ 本文鏈接：https://itrhx.blog.csdn.net/article/details/104870084 未經授權，禁止轉載！惡意轉載，后果自負！尊重原創，遠離剽竊！
【1x00】了解 NumPy
NumPy 是使用 Python 進行科學計算的基礎包，支持大量的維度數組與矩陣運算，對數組運算提供大量的數學函數庫。NumPy 重在數值計算，是大部分 Python 科學計算庫的基礎庫，多用于在大型、多維數組上執行數值運算。
NumPy 主要包含如下的內容：
- 一個強大的 N 維數組對象（Ndarray）；
- 復雜的廣播功能函數；
- 集成 C/C++/Fortran 代碼的工具；
- 具有線性代數、傅里葉變換、隨機數生成等功能。
【2x00】NumPy 數組與 Python 列表的區別
Numpy 使用 Ndarray 對象來處理多維數組，Python 列表通常存儲一維數組，通過列表的嵌套也可以實現多維數組。
Numpy 的 Ndarray 對象是一個快速而靈活的大數據容器。Numpy 專門針對數組的操作和運算進行了設計，所以數組的存儲效率和輸入輸出性能遠優于 Python 中的嵌套列表，數組越大，Numpy 的優勢就越明顯。
通常 Numpy 數組中的所有元素的類型都是相同的，而 Python 列表中的元素類型是任意的，所以在通用性能方面 Numpy 數組不及 Python 列表，但在科學計算中，可以省掉很多循環語句，代碼使用方面比 Python 列表簡單的多。
Python 列表的元素不同類型舉例：
>>> l = [True, '2', 3.2, 5] >>> [type(item) for item in l] [<class 'bool'>, <class 'str'>, <class 'float'>, <class 'int'>]Python 列表中的每一項必須包含各自的類型信息、引用計數和其他信息，也就是說，每一項都是一個完整的 Python 對象，同時，Python 列表還包含一個指向指針塊的指針，其中的每一個指針對應一個完整的 Python 對象，另外，列表的優勢是靈活，因為每個列表元素是一個包含數據和類型信息的完整結構體。相反 NumPy 數組缺乏這種靈活性，但是 NumPy 卻能更有效地存儲和操作數據。
【3x00】理解 NumPy Ndarray 對象
NumPy 提供了一個 N 維數組類型，即 Ndarray，它是一系列同類型數據的集合，是用于存放同類型元素的多維數組，以 0 下標為開始進行集合中元素的索引，所有 Ndarray 中的每個元素在內存中都有相同存儲大小的區域。
Ndarray 內部由以下內容組成：
- 一個指向數據（內存或內存映射文件中的一塊數據）的指針；
- 數據類型或 dtype，描述在數組中的固定大小值的格子；
- 一個表示數組形狀（shape）的元組，表示各維度大小的元組；
- 一個跨度元組（stride），其中的整數指的是為了前進到當前維度下一個元素需要“跨過”的字節數。
【4x00】理解不同維度的數組
NumPy 數組的維數稱為秩（rank），秩就是軸的數量，即數組的維度，一維數組的秩為 1，二維數組的秩為 2，以此類推。
在 NumPy 中，每一個線性的數組稱為是一個軸（axis），也就是維度（dimensions）。比如說，二維數組相當于是兩個一維數組，其中第一個一維數組中每個元素又是一個一維數組。所以一維數組就是 NumPy 中的軸（axis），第一個軸相當于是底層數組，第二個軸是底層數組里的數組。而軸的數量 — 秩，就是數組的維數。
很多時候可以聲明 axis，axis=0，表示沿著第 0 軸進行操作，即對每一列進行操作；axis=1，表示沿著第 1 軸進行操作，即對每一行進行操作。
一維數組：
>>> import numpy as np >>> a = np.array([1, 2, 3, 4]) >>> print(a) [1 2 3 4] >>> print(a.shape) (4,)二維數組：
>>> import numpy as np >>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) >>> print(a) [[1 2 3 4][5 6 7 8]] >>> print(a.shape) (2, 4)a.shape 輸出數組的維度，對于此二維數組，可以理解為 2 行 4 列。
三維數組：
>>> import numpy as np >>> a = np.array([[[1,2,3,4], [5,6,7,8]], [[9,10,11,12], [13,14,15,16]], [[17,18,19,20], [21,22,23,24]]]) >>> print(a) [[[ 1 2 3 4][ 5 6 7 8]][[ 9 10 11 12][13 14 15 16]][[17 18 19 20][21 22 23 24]]]>>> print(a.shape) (3, 2, 4)a.shape 輸出數組的維度，對于此三維數組，可以理解為 3 塊，每塊有 2 行 4 列。
有網友對三維數組的這個圖有疑問，認為橫線應該是 axis=0，豎線是 axis=1，斜線是 axis=2，這個確實有點兒繞，不要受到前面一維二維的影響，我把我的理解又畫了一張圖出來，另外大家可以嘗試去取三維數組里面的某個值，多想一下就可以理解了。歡迎各位大佬一起交流學習！
【5x00】創建 Ndarray 對象（創建數組）
【5x01】一張表快速了解創建數組的不同方法
| numpy.array() | 將輸入數據（列表、元組、Ndarray 等）轉換為數組形式 當數據源為 Ndarray 時，該方法仍然會 copy 出一個副本，占用新的內存 |
| numpy.asarray() | 將輸入數據（列表、元組、Ndarray 等）轉換為數組形式 當數據源為 Ndarray 時，該方法不會 copy 出一個副本，不占用新的內存 |
| numpy.arange() | 創建一個一維數組，該數組由一個等差數列構成 通過指定開始值、終值和步長創建等差數列，得到的結果數組不包含終值 |
| numpy.linspace() | 創建一個一維數組，該數組由一個等差數列構成 通過指定開始值、終值和元素個數創建等差數列，可通過 endpoint 參數指定是否包含終值 |
| numpy.logspace() | 創建一個一維數組，該數組由一個等比數列構成 |
| numpy.empty() | 創建一個指定形狀、數據類型且未初始化的數組 |
| numpy.zeros() | 創建一個指定大小的數組，數組元素以 0 來填充 |
| numpy.ones() | 創建一個指定大小的數組，數組元素以 1 來填充 |
| numpy.eye() | 創建一個對角矩陣數組，返回一個二維數組，對角線上值為 1，其余位置為 0 |
| numpy.frombuffer() | 將緩沖區解釋為一維數組，接受 buffer 輸入參數，以流的形式讀入并轉化成 Ndarray 對象 |
| numpy.fromiter() | 從可迭代對象中建立 Ndarray 對象，返回一個一維數組 |
【5x02】numpy.array()
調用 NumPy 的 array 方法即可創建一個 Ndarray 對象，即創建一個數組。
基本語法：numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
參數解釋：
| object | 數組或嵌套的數列 |
| dtype | 數組元素的數據類型，可選 |
| copy | 對象是否需要復制，可選 |
| order | 創建數組的樣式，C為行方向，F為列方向，A為任意方向（默認） |
| subok | 默認返回一個與基類類型一致的數組 |
| ndmin | 指定生成數組的最小維度 |
創建一個一維數組：
>>> import numpy as np >>> a = np.array([1, 2, 3]) >>> print(a) [1 2 3] >>> print(type(a)) <class 'numpy.ndarray'>創建一個二維數組：
>>> import numpy as np >>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> print(a) [[1 2 3][4 5 6]] >>> print(type(a)) <class 'numpy.ndarray'>創建一個三維數組：
>>> import numpy as np >>> a = np.array([[[1,2,3], [4,5,6]], [[7,8,9], [10,11,12]]]) >>> print(a) [[[ 1 2 3][ 4 5 6]][[ 7 8 9][10 11 12]]]【5x03】numpy.asarray()
numpy.asarray() 方法將輸入數據（列表、元組、Ndarray 等）轉換為數組形式，與 numpy.array() 方法類似，但 asarray 參數比 array 少兩個，另外最大的區別是當數據源為 Ndarray 時，array 方法仍然會 copy 出一個副本，占用新的內存，但 asarray 方法不會。
基本語法：numpy.asarray(a, dtype=None, order=None)
參數解釋：
| a | 待轉換對象，可以是列表，元組，列表元組，元組列表，多維數組等 |
| dtype | 可選項，指定數據類型 |
| order | 可選項，以行優先（C）或列優先（F）的順序存儲多維數據在內存中 |
將列表轉換為 Ndarray：
>>> import numpy as np >>> l = [1,2,3,4] >>> n = np.asarray(l) >>> print(n) [1 2 3 4] >>> print(type(n)) <class 'numpy.ndarray'>將元組轉換為 Ndarray：
>>> import numpy as np >>> l = (1,2,3,4) >>> n = np.asarray(l) >>> print(n) [1 2 3 4] >>> print(type(n)) <class 'numpy.ndarray'>將元組列表轉換為 Ndarray：
>>> import numpy as np >>> l = [(1,2,3),(4,5)] >>> n = np.asarray(l) >>> print(n) [(1, 2, 3) (4, 5)] >>> print(type(n)) <class 'numpy.ndarray'>指定 dtype 參數：
>>> import numpy as np >>> l = [1,2,3] >>> n = np.asarray(l, dtype=float) >>> print(n) [1. 2. 3.] >>> print(type(n)) <class 'numpy.ndarray'>numpy.asarray() 方法和 numpy.array() 的區別演示：
當輸入數據為列表、元組等格式時，兩者沒有區別，都可以將其轉為數組格式：
>>> import numpy as np >>> a = [[1,2,3], [4,5,6], [7,8,9]] >>> b = np.array(a) >>> c = np.asarray(a) >>> a[1] = 0 >>> print(a) [[1, 2, 3], 0, [7, 8, 9]] >>> print(type(a)) # a 為列表 <class 'list'> >>> print(b) # 列表對象 a 的值改變，array 方法得到的值不會改變 [[1 2 3][4 5 6][7 8 9]] >>> print(c) # 列表對象 a 的值改變，asarray 方法得到的值不會改變 [[1 2 3][4 5 6][7 8 9]]當輸入數據為 Ndarray 時，array 方法仍然會 copy 出一個副本，占用新的內存，但 asarray 方法不會：
>>> import numpy as np >>> a = np.ones((3,3)) >>> b = np.array(a) >>> c = np.asarray(a) >>> a[1][1] = 2 >>> print(a) [[1. 1. 1.][1. 2. 1.][1. 1. 1.]] >>> print(type(a)) # a 為 Ndarray 對象 <class 'numpy.ndarray'> >>> print(b) # Ndarray 對象 a 的值改變，array 方法得到的值不會改變 [[1. 1. 1.][1. 1. 1.][1. 1. 1.]] >>> print(c) # Ndarray 對象 a 的值改變，asarray 方法得到的值也將改變 [[1. 1. 1.][1. 2. 1.][1. 1. 1.]]【5x04】numpy.arange()
numpy.arange() 方法用于創建一個一維數組，在指定的間隔內返回均勻間隔的數字并組成數組（Ndarray 對象），即該數組是一個等差數列構成的。arange() 類似 Python 的 range()，但是 arange() 的步長可以為小數，而 range() 的步長只能是整數。
基本語法：numpy.arange([start, ]stop, [step, ]dtype=None)
參數解釋：
| start | 起始值，數字，可選項，默認起始值為 0，生成的元素包括起始值 |
| stop | 結束值，數字，生成的元素不包括結束值 |
| step | 步長，數字，可選項， 默認步長為 1，如果指定了 step，則必須給出 start |
| dtype | 輸出數組的類型，如果未給出 dtype，則從其他輸入參數推斷數據類型 |
應用舉例：
>>> import numpy as np >>> a = np.arange(5) # 相當于 np.array([0, 1, 2, 3, 4]) >>> b = np.arange(2, 5) # 相當于 np.array([2, 3, 4]) >>> c = np.arange(2, 9, 3) >>> print('a = %s\nb = %s\nc = %s' %(a,b,c)) a = [0 1 2 3 4] b = [2 3 4] c = [2 5 8]【5x05】numpy.linspace()
numpy.linspace() 方法用于創建一個一維數組，在指定的間隔內返回均勻間隔的數字并組成數組（Ndarray 對象），即該數組是一個等差數列構成的。linspace() 方法類似于 arange()，兩者除了參數有差別以外，還有以下的區別：
-
arange() 方法類似于內置函數 range()，通過指定開始值、終值和步長創建表示等差數列的一維數組，得到的結果數組不包含終值。
-
linspace() 通過指定開始值、終值和元素個數創建表示等差數列的一維數組，可以通過 endpoint 參數指定是否包含終值，默認值為True，即包含終值。
基本語法：numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
參數解釋：
| start | 序列的起始值 |
| stop | 序列的終止值，如果 endpoint 為 True，則該值將包含于數列中 |
| num | 可選項，int 類型，要生成的等步長的樣本數量，即元素個數，默認為 50 |
| endpoint | 可選項，bool 類型，該值為 True 時，數列中將包含 stop 值，反之則不包含，默認為 True |
| retstep | 可選項，bool 類型，該值為 True 時，生成的數組中會顯示間距，反之則不顯示，默認為 False |
| dtype | 可選項，Ndarray 的數據類型 |
| axis | 可選項，int 類型，結果中的軸用于存儲樣本。僅當 start 或 stop 類似于數組時才相關 默認情況下為 0，采樣將沿著在開始處插入的新軸進行，使用 -1 來獲得軸的末端 |
應用舉例：
不指定 num 值，將默認生成 50 個元素，數列中將包含 stop 值：
>>> import numpy as np >>> a = np.linspace(1, 10) >>> print(a) [ 1. 1.18367347 1.36734694 1.55102041 1.73469388 1.918367352.10204082 2.28571429 2.46938776 2.65306122 2.83673469 3.020408163.20408163 3.3877551 3.57142857 3.75510204 3.93877551 4.122448984.30612245 4.48979592 4.67346939 4.85714286 5.04081633 5.22448985.40816327 5.59183673 5.7755102 5.95918367 6.14285714 6.326530616.51020408 6.69387755 6.87755102 7.06122449 7.24489796 7.428571437.6122449 7.79591837 7.97959184 8.16326531 8.34693878 8.530612248.71428571 8.89795918 9.08163265 9.26530612 9.44897959 9.632653069.81632653 10. ]指定 num 值為 10，將生成 10 個元素，數列中將包含 stop 值：
>>> import numpy as np >>> a = np.linspace(1, 10, 10) >>> print(a) [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]指定 endpoint 值為 False，retstep 值為 True，數列中不包含 stop 值，生成的數組中會顯示間距：
>>> import numpy as np >>> a = np.linspace(1, 10, 10, endpoint=False, retstep=True) >>> print(a) (array([1. , 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1]), 0.9)指定 dtype 類型為 int：
>>> import numpy as np >>> a = np.linspace(1, 10, 10, endpoint=False, retstep=True, dtype=int) >>> print(a) (array([1, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 0.9)【5x06】numpy.logspace()
numpy.logspace() 方法用于創建一個一維數組，該數組由一個等比數列構成。
基本語法：numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
參數解釋：
| start | 序列的起始值 |
| stop | 序列的終止值，如果 endpoint 為 True，則該值將包含于數列中 |
| num | 可選項，int 類型，要生成的等步長的樣本數量，即元素個數，默認為 50 |
| endpoint | 可選項，bool 類型，該值為 True 時，數列中將包含 stop 值，反之則不包含，默認為 True |
| base | 可選項，float 類型，對數 log 的底數，即取對數的時候 log 的下標 ，默認為 10.0 |
| dtype | 可選項，Ndarray 的數據類型 |
| axis | 可選項，int 類型，結果中的軸用于存儲樣本。僅當 start 或 stop 類似于數組時才相關 默認情況下為 0，采樣將沿著在開始處插入的新軸進行，使用 -1 來獲得軸的末端 |
應用舉例：
指定起始值為 0，,終止值為 9，base 默認值為 10，代表的是 10 的冪，即 0 代表 10 的 0 次方，9 代表 10 的 9 次方：
>>> import numpy as np >>> a = np.logspace(0, 9, num = 10) >>> print(a) [1.e+00 1.e+01 1.e+02 1.e+03 1.e+04 1.e+05 1.e+06 1.e+07 1.e+08 1.e+09]指定起始值為 0，,終止值為 9，base 值為 2，代表的是 2 的冪，即 0 代表 2 的 0 次方，9 代表 2 的 9 次方：
>>> import numpy as np >>> a = np.logspace(0, 9, num = 10, base = 2) >>> print(a) [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]起始值和終止值都可以為 float 類型：
>>> import numpy as np >>> a = np.logspace(1.0, 2.0, num = 10) >>> print(a) [ 10. 12.91549665 16.68100537 21.5443469 27.8255940235.93813664 46.41588834 59.94842503 77.42636827 100. ]定義 dtype 屬性值為 int 類型：
>>> import numpy as np >>> a = np.logspace(0.0, 9.0, num = 10, base = 2, dtype = int) >>> print(a) [ 1 2 4 8 16 32 64 128 256 512]【5x07】numpy.empty()
numpy.empty() 方法可用來創建一個指定形狀（shape）、數據類型（dtype）且未初始化的數組。
基本語法：numpy.empty(shape, dtype = float, order = 'C')
參數解釋：
| shape | 數組形狀 |
| dtype | 數據類型，可選 |
| order | 以行優先（C）或列優先（F）的順序存儲多維數據在內存中 |
創建一個一維空數組（傳遞一個參數即可，代表數組長度，數組元素為隨機值，因為它們未初始化）：
>>> import numpy as np >>> a = np.empty(3) >>> print(a) [3.538e-321 3.538e-321 0.000e+000] >>> print(type(a)) <class 'numpy.ndarray'> >>> >>> a = np.empty(3, dtype = int) # 定義類型為整數 >>> print(a) [716 0 716]創建一個二維空數組（傳遞兩個參數，分別代表行數和列數）：
>>> import numpy as np >>> a = np.empty([3, 2]) >>> print(a) [[6.23042070e-307 3.56043053e-307][1.37961641e-306 1.11258854e-306][8.90100843e-307 1.11261027e-306]] >>> print(type(a)) <class 'numpy.ndarray'>創建一個三維空數組（傳遞三個參數，分別代表塊數、每一塊的行數和列數）：
>>> import numpy as np >>> a = np.empty([3, 2, 4]) >>> print(a) [[[0. 0. 0. 0.][0. 0. 0. 0.]][[0. 0. 0. 0.][0. 0. 0. 0.]][[0. 0. 0. 0.][0. 0. 0. 0.]]]【5x08】numpy.zeros()
numpy.zeros() 方法用于創建指定大小的數組，數組元素以 0 來填充。
基本語法：numpy.zeros(shape, dtype = float, order = 'C')
參數解釋：
| shape | 數組形狀 |
| dtype | 數據類型，可選 |
| order | 以行優先（C）或列優先（F）的順序存儲多維數據在內存中 |
創建一個一維數組（傳遞一個參數即可，代表數組長度，數組元素以 0 填充）：
>>> import numpy as np >>> a = np.zeros(5) >>> print(a) [0. 0. 0. 0. 0.] >>> print(type(a)) <class 'numpy.ndarray'> >>> >>> a = np.zeros(5, dtype = int) # 定義類型為整數 >>> print(a) [0 0 0 0 0]創建一個二維數組（傳遞兩個參數，分別代表行數和列數）：
>>> import numpy as np >>> a = np.zeros([2, 3]) >>> print(a) [[0. 0. 0.][0. 0. 0.]] >>> print(type(a)) <class 'numpy.ndarray'>創建一個三維空數組（傳遞三個參數，分別代表塊數、每一塊的行數和列數）：
>>> import numpy as np >>> a = np.zeros([4, 2, 3]) >>> print(a) [[[0. 0. 0.][0. 0. 0.]][[0. 0. 0.][0. 0. 0.]][[0. 0. 0.][0. 0. 0.]][[0. 0. 0.][0. 0. 0.]]] >>> print(type(a)) <class 'numpy.ndarray'>【5x09】numpy.ones()
numpy.ones() 方法用于創建指定大小的數組，數組元素以 1 來填充。
基本語法：numpy.ones(shape, dtype = None, order = 'C')
參數解釋：
| shape | 數組形狀 |
| dtype | 數據類型，可選 |
| order | 以行優先（C）或列優先（F）的順序存儲多維數據在內存中 |
創建一個一維數組（傳遞一個參數即可，代表數組長度，數組元素以 0 填充）：
>>> import numpy as np >>> a = np.ones(5) >>> print(a) [1. 1. 1. 1. 1.] >>> print(type(a)) <class 'numpy.ndarray'> >>> >>> a = np.ones(5, dtype = int) # 定義類型為整數 >>> print(a) [1 1 1 1 1] >>> print(type(a)) <class 'numpy.ndarray'>創建一個二維數組（傳遞兩個參數，分別代表行數和列數）：
>>> import numpy as np >>> a = np.ones([2, 3]) >>> print(a) [[1. 1. 1.][1. 1. 1.]] >>> print(type(a)) <class 'numpy.ndarray'>創建一個三維數組（傳遞三個參數，分別代表塊數、每一塊的行數和列數）：
>>> import numpy as np >>> a = np.ones([3, 2 ,5]) >>> print(a) [[[1. 1. 1. 1. 1.][1. 1. 1. 1. 1.]][[1. 1. 1. 1. 1.][1. 1. 1. 1. 1.]][[1. 1. 1. 1. 1.][1. 1. 1. 1. 1.]]] >>> print(type(a)) <class 'numpy.ndarray'>【5x10】numpy.eye()
numpy.eye() 方法用于創建對角矩陣數組，返回一個二維數組，對角線上值為 1，其余位置為 0。
基本語法：numpy.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
參數解釋：
| N | int 類型，目標數組的行數 |
| M | int 類型，可選項，目標數組的列數，如果未指定，則默認與行數（N）相同 |
| k | int 類型，可選項，對角線索引，0（默認值）為主對角線，正值為上對角線，負值為下對角線 簡單來說可以理解成將值為 1 的對角線向左右平移 k 個單位，默認值 0 即對角線為 1，k 為正值右移，負值左移 |
| dtype | 可選項，返回數組的數據類型 |
| order | 可選項，以行優先（C）或列優先（F）的順序存儲多維數據在內存中 |
應用舉例：
>>> import numpy as np >>> print(np.eye(5, 5)) # 創建一個對角矩陣 [[1. 0. 0. 0. 0.][0. 1. 0. 0. 0.][0. 0. 1. 0. 0.][0. 0. 0. 1. 0.][0. 0. 0. 0. 1.]] >>> print(np.eye(5, 5, k=1)) # 將值為 1 的對角線向右移 1 個單位 [[0. 1. 0. 0. 0.][0. 0. 1. 0. 0.][0. 0. 0. 1. 0.][0. 0. 0. 0. 1.][0. 0. 0. 0. 0.]] >>> print(np.eye(5, 5, k=-2)) # 將值為 1 的對角線向右左移 2 個單位 [[0. 0. 0. 0. 0.][0. 0. 0. 0. 0.][1. 0. 0. 0. 0.][0. 1. 0. 0. 0.][0. 0. 1. 0. 0.]] >>> print(np.eye(5, dtype=int)) # 指定為 int 類型 [[1 0 0 0 0][0 1 0 0 0][0 0 1 0 0][0 0 0 1 0][0 0 0 0 1]]【5x11】numpy.frombuffer()
numpy.frombuffer() 方法將緩沖區解釋為一維數組，接受 buffer 輸入參數，以流的形式讀入轉化成 ndarray 對象。當 buffer 是字符串時，Python3 默認 str 是 Unicode 類型，所以要轉成 bytestring，即在原 str 前加上 b。
基本語法：numpy.frombuffer(buffer, dtype=float, count=-1, offset=0)
參數解釋：
| buffer | 可以是任意對象，會以流的形式讀入 |
| dtype | 可選項，返回數組的數據類型 |
| count | 可選項，讀取的數據數量，默認為 -1，即讀取緩沖區中所有數據 |
| offset | 可選項，讀取的起始位置，以字節為單位，默認為 0 |
應用舉例：
>>> import numpy as np >>> a = b'I love python!' >>> b = np.frombuffer(a, dtype='S1') >>> print(b) [b'I' b' ' b'l' b'o' b'v' b'e' b' ' b'p' b'y' b't' b'h' b'o' b'n' b'!'] >>> >>> b = np.frombuffer(a, dtype='S1', count=5) # 指定要讀取的數據量 >>> print(b) [b'I' b' ' b'l' b'o' b'v'] >>> >>> b = np.frombuffer(a, dtype='S1', count=5, offset=6) # 指定讀取數據的起始位置 >>> print(b) [b' ' b'p' b'y' b't' b'h'] >>> >>> import numpy as np >>> a = b'\x01\x02' >>> b = np.frombuffer(a, dtype='uint8') >>> print(b) [1 2]【5x12】numpy.fromiter()
numpy.fromiter() 方法可以從可迭代對象中建立 Ndarray 對象，返回一個一維數組。
基本語法：numpy.fromiter(iterable, dtype, count=-1)
參數解釋：
| iterable | 可迭代對象 |
| dtype | 返回數組的數據類型 |
| count | 讀取的數據數量，默認為 -1，即讀取所有數據 |
應用舉例：
>>> import numpy as np >>> l = range(5) >>> i = iter(l) # iter() 方法用于生成迭代器 >>> n = np.fromiter(i, dtype=float) # 從可迭代對象中建立 Ndarray 對象 >>> print(l, type(l)) range(0, 5) <class 'range'> >>> print(i, type(i)) <range_iterator object at 0x00000163E75DCA70> <class 'range_iterator'> >>> print(n, type(n)) [0. 1. 2. 3. 4.] <class 'numpy.ndarray'>這里是一段防爬蟲文本，請讀者忽略。 本文原創首發于 CSDN，作者 TRHX。 博客首頁：https://itrhx.blog.csdn.net/ 本文鏈接：https://itrhx.blog.csdn.net/article/details/104870084 未經授權，禁止轉載！惡意轉載，后果自負！尊重原創，遠離剽竊！
【6x00】改變數組的維度或者形狀
【6x01】numpy.reshape()
numpy.reshape() 方法用于重新調整數組的維數（重塑）。
基本語法：numpy.reshape(a, newshape, order='C')
參數解釋：
a：要重塑的數組
newshape：重塑后的形狀，新形狀應與原始形狀兼容。如果是整數，則結果將是該長度的一維數組。一個形狀維度可以是-1。在這種情況下，將根據數組的長度和剩余維度推斷該值。舉個例子，原數組 a 是一個 4 行 n 列的二維數組，現在要將其轉換成只有 1 行的一維數組，由于不清楚原二維數組有多少列，也就不清楚一共有多少元素，所以可以使用 np.reshape(a, (1, -1)) 語句將其轉化為一維數組，其中 -1 會讓程序自動計算有多少列，此概念將在后面舉例具體說明。
order：可選值為 C、F、A，使用索引順序讀取 a 的元素，并按照索引順序將元素放到變換后的的數組中，默認參數為 C。
C 指的是用類 C 寫的讀/索引順序的元素，最后一個維度變化最快，第一個維度變化最慢。橫著讀，橫著寫，優先讀/寫一行。
F 是指用 FORTRAN 類索引順序讀/寫元素，最后一個維度變化最慢，第一個維度變化最快。豎著讀，豎著寫，優先讀/寫一列。注意，C 和 F 選項不考慮底層數組的內存布局，只引用索引的順序。
A 選項所生成的數組的效果與原數組 a 的數據存儲方式有關，如果數據是按照 FORTRAN 存儲的話，它的生成效果與 F 相同，否則與 C 相同。
應用舉例：
>>> import numpy as np >>> a = np.array([1,2,3,4,5,6,7,8]) # 創建一個一維數組 >>> print(a) [1 2 3 4 5 6 7 8] >>> b = np.reshape(a, (2,4)) # 重塑為一個二維數組 >>> print(b) [[1 2 3 4][5 6 7 8]] >>> c = np.reshape(a, (2,2,2)) # 重塑為一個三維數組 >>> print(c) [[[1 2][3 4]][[5 6][7 8]]]添加 order 參數舉例：
>>> import numpy as np >>> a = np.array([[1,2,3], [4,5,6]]) # 創建一個二維數組 >>> print(a) [[1 2 3][4 5 6]] >>> b = np.reshape(a, 6, order='C') # 按照行優先 >>> print(b) [1 2 3 4 5 6] >>> b = np.reshape(a, 6, order='F') # 按照列優先 >>> print(b) [1 4 2 5 3 6]另外，reshape 方法新生成的數組和原數組共用一個內存，不管改變哪個都會互相影響：
>>> import numpy as np >>> a = np.array([1,2,3,4,5,6,7,8]) >>> b = np.reshape(a, (2,4)) >>> print(a) [1 2 3 4 5 6 7 8] >>> print(b) [[1 2 3 4][5 6 7 8]] >>> a[0] = 666 >>> print(a) [666 2 3 4 5 6 7 8] >>> print(b) [[666 2 3 4][ 5 6 7 8]]newshape 重塑后的形狀維度可以是 -1，簡單舉例：
-
reshape(1,-1)：將原數組轉化成一行 N 列
-
reshape(2,-1)：將原數組轉換成兩行 N 列
-
reshape(-1,1)：將原數組轉換成一列 N 行
-
reshape(-1,2)：將原數組轉化成兩列 N 行
【6x02】numpy.ravel()
numpy.ravel() 方法用于完成展平的操作。
基本語法：numpy.ravel(a, order='C')
參數解釋：
| a | 待轉換的數組 |
| order | 值可以是 C F A K，含義與 reshape 方法中參數的一樣，與 reshape 方法不同的是多了個值 K K 表示按順序在內存中讀取元素，但在跨距為負時會反轉數據 |
應用舉例：
>>> import numpy as np >>> a = np.array([[[1,2,3,4], [5,6,7,8]], [[9,10,11,12], [13,14,15,16]], [[17,18,19,20], [21,22,23,24]]]) >>> print(a) [[[ 1 2 3 4][ 5 6 7 8]][[ 9 10 11 12][13 14 15 16]][[17 18 19 20][21 22 23 24]]] >>> print(a.ravel()) [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24] >>> print(np.ravel(a)) [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]【6x03】numpy.resize()
numpy.resize() 方法會直接修改所操作的數組，返回具有指定形狀的新數組，如果新數組大于原始數組，則新數組將填充 a 的重復副本。
基本語法：numpy.resize(a, new_shape)
參數解釋：
| a | 待轉換的數組 |
| new_shape | 新數組的大小形狀 |
【6x04】numpy.ndarray.flatten()
numpy.ndarray.flatten() 方法恰如其名，flatten 就是展平的意思，與 ravel 函數的功能相同，二者的不同之處在于：flatten 方法會請求分配新的內存來保存結果，而 ravel 方法只是返回數組的一個視圖（view）。
基本語法：ndarray.flatten(order='C')
其 order 參數的值可以是 C F A K，含義與 reshape 和 ravel 方法中參數的一樣.
應用舉例：
>>> import numpy as np >>> a = np.array([[[1,2,3,4], [5,6,7,8]], [[9,10,11,12], [13,14,15,16]], [[17,18,19,20], [21,22,23,24]]]) >>> print(a) [[[ 1 2 3 4][ 5 6 7 8]][[ 9 10 11 12][13 14 15 16]][[17 18 19 20][21 22 23 24]]] >>> print(a.flatten()) [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]【6x05】numpy.ndarray.shape
numpy.ndarray.shape 本來是 Ndarray 對象的一個屬性，但可以通過直接用一個正整數元組對其賦值來設置數組的維度：
>>> import numpy as np >>> a = np.array([[[1,2,3,4], [5,6,7,8]], [[9,10,11,12], [13,14,15,16]], [[17,18,19,20], [21,22,23,24]]]) >>> print(a) [[[ 1 2 3 4][ 5 6 7 8]][[ 9 10 11 12][13 14 15 16]][[17 18 19 20][21 22 23 24]]] >>> a.shape = (3, 8) >>> print(a) [[ 1 2 3 4 5 6 7 8][ 9 10 11 12 13 14 15 16][17 18 19 20 21 22 23 24]]【6x06】numpy.ndarray.transpose() & numpy.ndarray.T
ndarray.transpose() 和 ndarray.T 方法的作用是對數組進行轉置，即原來的行變成列，原來的列變成行。
>>> import numpy as np >>> a = np.array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17]]) >>> print(a) [[ 0 1 2 3 4 5][ 6 7 8 9 10 11][12 13 14 15 16 17]] >>> print(a.transpose()) [[ 0 6 12][ 1 7 13][ 2 8 14][ 3 9 15][ 4 10 16][ 5 11 17]] >>> print(a.T) [[ 0 6 12][ 1 7 13][ 2 8 14][ 3 9 15][ 4 10 16][ 5 11 17]]【6x07】numpy.swapaxes()
numpy.swapaxes() 方法用于對換數組的兩個軸
基本語法：numpy.swapaxes(a, axis1, axis2)
參數解釋：a 為原始數組，axis1、axis2 分別對應兩個軸，類型為整數
>>> import numpy as np >>> a = np.array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17]]) >>> print(a) [[ 0 1 2 3 4 5][ 6 7 8 9 10 11][12 13 14 15 16 17]] >>> print(np.swapaxes(a, 1, 0)) # 交換 1 軸和 0 軸，此處相當于數組的轉置，與【6x06】效果相同 [[ 0 6 12][ 1 7 13][ 2 8 14][ 3 9 15][ 4 10 16][ 5 11 17]]【7x00】NumPy 數據類型
NumPy 數組包含同一類型的值，支持的數據類型比 Python 內置的類型更多，構建一個數組時，可以用一個字符串參數 dtype 來指定數據類型：
np.zeros(10, dtype='int16') np.zeros(10, dtype=np.int16)| bool_ | ??????????????布爾值（True 或者 False），用一個字節存儲 |
| int_ | ??????????????默認的整型（類似于 C 語言中的 long，通常情況下是 int32 或 int64） |
| intc | ??????????????同 C 語言的 int 相同（通常是 int32 或 int64） |
| intp | ??????????????用作索引的整型（和 C 語言的 ssize_t 相同，通常情況下是 int32 或 int64） |
| int8 | ??????????????字節（byte，范圍從 –128 到 127），可用 i1 縮寫代替 |
| int16 | ??????????????整型（范圍從 –32768 到 32767），可用 i2 縮寫代替 |
| int32 | ??????????????整型（范圍從 –2147483648 到 2147483647），可用 i4 縮寫代替 |
| int64 | ??????????????整型（范圍從 –9223372036854775808 到 9223372036854775807），可用 i8 縮寫代替 |
| uint8 | ??????????????無符號整型（范圍從 0 到 255） |
| uint16 | ??????????????無符號整型（范圍從 0 到 65535） |
| uint32 | ??????????????無符號整型（范圍從 0 到 4294967295） |
| uint64 | ??????????????無符號整型（范圍從 0 到 18446744073709551615） |
| float_ | ??????????????float64 的簡化形式 |
| float16 | ??????????????半精度浮點型，包括：1 比特位符號，5 比特位指數，10 比特位尾數 |
| float32 | ??????????????單精度浮點型，包括：1 比特位符號，8 比特位指數，23 比特位尾數 |
| float64 | ??????????????雙精度浮點型，包括：1 比特位符號，11 比特位指數，52 比特位尾數 |
| complex_ | ??????????????complex128 的簡化形式 |
| complex64 | ??????????????復數，表示雙 32 位浮點數（實數部分和虛數部分） |
| complex128 | ??????????????復數，表示雙 64 位浮點數（實數部分和虛數部分） |
【8x00】NumPy 數組屬性
| ndarray.ndim | 秩，即軸的數量或維度的數量，一維數組的秩為 1，二維數組的秩為 2，以此類推 |
| 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.flags 包含以下屬性：
| C_CONTIGUOUS (C) | 數據是在一個單一的 C 風格的連續段中 |
| F_CONTIGUOUS (F) | 數據是在一個單一的 Fortran 風格的連續段中 |
| OWNDATA (O) | 數組擁有它所使用的內存或從另一個對象中借用它 |
| WRITEABLE (W) | 數據區域可以被寫入，將該值設置為 False，則數據為只讀 |
| ALIGNED (A) | 數據和所有元素都適當地對齊到硬件上 |
| UPDATEIFCOPY (U) | 這個數組是其它數組的一個副本，當這個數組被釋放時，原數組的內容將被更新 |
應用舉例：
>>> import numpy as np >>> a = np.array([1,2,3,4,5]) >>> print(a.flags)C_CONTIGUOUS : TrueF_CONTIGUOUS : TrueOWNDATA : TrueWRITEABLE : TrueALIGNED : TrueWRITEBACKIFCOPY : FalseUPDATEIFCOPY : Falsendarray.shape 查看數組維度以及更改數組形狀：
>>> import numpy as np >>> a = np.array([[1,2,3],[4,5,6]]) >>> print(a) [[1 2 3][4 5 6]] >>> print(a.shape) (2, 3) >>> a.shape = (3, 2) >>> print(a) [[1 2][3 4][5 6]] >>> print(a.shape) (3, 2)這里是一段防爬蟲文本，請讀者忽略。 本文原創首發于 CSDN，作者 TRHX。 博客首頁：https://itrhx.blog.csdn.net/ 本文鏈接：https://itrhx.blog.csdn.net/article/details/104870084 未經授權，禁止轉載！惡意轉載，后果自負！尊重原創，遠離剽竊！
總結
以上是生活随笔為你收集整理的Python 数据分析三剑客之 NumPy（一）：理解 NumPy / 数组基础的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 人民币国际支付市场份额两连升，美元份额大
- 下一篇： 【Python CheckiO 题解】P