1.ndarray數據結構
2.創建ndarray
3.ndarray的數據類型
4.數組和標量之間的運算
5.基本的索引
6.通用函數
7.利用數組進行數據處理
8.輸入輸出
NumPy(Numerical Python的簡稱)是高性能科學計算和數據分析的基礎包。是用python進行數據分析與挖掘的構建基礎。
NumPy本身並沒有提供多麼高級的數據分析功能，理解NumPy數組以及面向數組的計算將有助你更加高效地使用諸如pandas之類的工具。如果你是Python新手，而且只是想用Pandas隨便處理一下數據就行，那就跳過此章吧，沒關係的。
1.ndarray數據結構
ndarray是NumPy中一種多維數組對象。我們先來看兩個實例。
In [3]: array1
Out[3]: array([1, 2, 3, 4, 5, 6, 7, 8])
In [3]:和Out[3]:是Jupyter編輯器的輸入輸出標誌，你可以理解爲代碼塊行號。array1便是一個一維的ndarray對象。我們多看兩個：
In [5]: array2
Out[5]: array([[1, 2, 3, 4],
[5, 6, 7, 8]])
array2是一個2 * 4的二維ndarray對象。
In [7]: array3
Out[7]: array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
array3是一個2 * 2 * 2的三維ndarray對象。
ndarray是一個通用的同構數據多維容器，其中的所有元素必須是相同類型。每個ndarray都有一個shape(表示各維度大小的對象),一個dtype(數組數據類型對象)和一個ndim(數組緯度的對象)：
In [8]: array3.shape
Out[8]: (2, 2, 2)
In [9]: array3.dtype
Out[9]: dtype('int64')
In [10]: array3.ndim
Out[9]: 3
2.創建ndarray
2.1 NumPy的array函數
創建數組最簡單的辦法就是array函數，以一個列表的轉換爲例：
#導入numpy模塊
In [10]: import numpy as np
In [11]: data = [1,2,3,4,5,6,7,8]
array1 = np.array(data)
In [12]: array1
Out[12]: array([1, 2, 3, 4, 5, 6, 7, 8])
嵌套列表將會被轉化爲一個多維數組：
In [13]: data = [[1,2,3,4],[5,6,7,8]]
array2 = np.array(data)
In [14]: array2
Out[14]: array([[1, 2, 3, 4],
[5, 6, 7, 8]])
2.2 NumPy的arange函數
arange函數是python內置函數的數組版：
In [15]: np.arange(10)
Out[15]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
也可以創建一個多維數組：
In [16]: np.arange(10).reshape((2,5))
Out[16]: array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
下面表顯示更多的ndarray創建函數：
| 函數 | 說明 |
|---|---|
| array | 將輸入數據(列表、元組、數組或其他序列類型)轉換爲ndarray。要麼推斷出dtype,要麼顯示指定dtype。默認直接複製輸入數據 |
| asarray | 將輸入轉化爲ndarray,如果輸入本身就是一個ndarray就不進行復制 |
| arange | 類似內置的range，但返回的是一個ndarray而不是列表 |
| ones、ones_like | 根據指定的形狀和dtype創建一個全1的數組。ones_like以另外一個數組爲參數，並根據其形狀和dtype創建一個全1數組 |
| zeros、zeros_like | 類似與ones和ones_like,只不過產生的是全0數組 |
| empty、empty_like | 創建新數組，只分配內存空間但不填充任何值 |
| eye、identity | 創建一個正方的N * N單位矩陣(對角線爲1，其餘爲0) |
3.ndarray的數據類型
dtype(數據類型)是一個特殊的對象。數值型的dtype的命名方式相同：一個類型名(如int或float),後面跟一個表示各元素位長的數字。python中的float對象需要佔用8個字節(即64位)，因此，該類型在NumPy中就記作float64。
舉個例子：
In [18]: array1 = np.array([1,2,3,4], dtype=np.int64)
array1.dtype
Out[18]: dtype('int64')
In [19]: array2 = np.array([1,2,3,4], dtype=np.float64)
array2.dtype
Out[19]: dtype('float64')
4.數組和標量之間的運算
數組很重要，因爲它使你不用編寫循環即可對數據執行批量運算。這通常就叫做矢量化。大小相等的數組之間的任何算術運算都會將運算應用到元素級：
In [20]: arr = np.array([[1,2,3,4],[5,6,7,8]])
arr
Out[20]: array([[1, 2, 3, 4],
[5, 6, 7, 8]])
In [25]: arr * arr
Out[25]: array([[ 1, 4, 9, 16],
[25, 36, 49, 64]])
In [26]: arr - arr
Out[26]: array([[0, 0, 0, 0],
[0, 0, 0, 0]])
數組與標量的算術運算也會將那個標量值傳播到各個元素：
In [27]: arr * 0.5
Out[27]: array([[0.5, 1. , 1.5, 2. ],
[2.5, 3. , 3.5, 4. ]])
不同大小的數組之間的運算叫做廣播，本篇不作講解。
5.基本的索引
NumPy數組的索引是一個內容豐富的主題，因爲選取數據的子集或單個元素的方式有很多。
5.1 整數索引
一維數組很簡單，從表面上看跟Python列表的功能差不多：
In [30]: arr = np.arange(10)
arr
Out[30]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [33]: arr[3]
Out[33]: 3
對於高維度數組，能做的事情跟多。例如在一個二維數組中，各索引位置上的元素不再是標量而是一維數組：
In [39]: arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2d
Out[39]: array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [42]: arr2d[1]
Out[42]: array([4, 5, 6])
因此對元素的遞歸訪問可以傳入一個逗號隔開的索引列表來選取單個元素。下面兩種方法是等價的。
In [43]: arr2d[1,2]
Out[43]: 6
In [44]: arr2d[1][2]
Out[44]: 6
在多維數組中，如果省略了後面的索引，則返回對象是一個維度低一點的ndarray。
舉個例子，在一個2 * 2 * 3的三維數組當中：
In [45]: arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
arr3d
Out[45]: array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
arr3d[0]是一個2 * 3的二維數組：
In [46]: arr3d[0]
Out[46]: array([[1, 2, 3],
[4, 5, 6]])
️在上面所有這些選取數組子集的例子中，返回的數組都是原始數組的視圖。這意味着數據不會被複制，視圖上的任何修改都會直接反映到源數組上。
舉個例子：
In [47]: arr3d[0] = 12
In [48]: arr3d
Out[48]: array([[[12, 12, 12],
[12, 12, 12]],
[[ 7, 8, 9],
[10, 11, 12]]])
️如果你想要得到的是ndarray切片的一份副本而非視圖，就需要顯示地進行復制操作，例如arr3d[0].copy()
5.2 切片索引
ndarray的切片語法跟Python列表這樣的一維對象差不多:
In [56]: arr
Out[56]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [57]: arr[1:5]
Out[57]: array([1, 2, 3, 4])
高維度的數組切片方法更多，你可以在一個軸或多個軸上進行切片。
舉個例子：
In [58]: arr2d
Out[58]: array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [60]: arr2d[0:2]
Out[60]: array([[1, 2, 3],
[4, 5, 6]])
In [61]: arr2d[:2]
Out[61]: array([[1, 2, 3],
[4, 5, 6]])
上面的兩種寫法是一樣的。
切片是沿着一個軸方向選取元素的，你可以一次傳入多個切片，就像傳入多個索引那樣(用逗號隔開)：
In [62]: arr2d[:2,1:]
Out[62]: array([[2, 3],
[5, 6]])
️'只有冒號'表示選取整個軸。
舉個例子：
In [64]: arr2d[:]
Out[64]: array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [65]: arr2d[:,1:]
Out[65]: array([[2, 3],
[5, 6],
[8, 9]])
整數索引和切片索引可以混合使用：
In [67]: arr2d[1,1:]
Out[67]: array([5, 6])
️切片索引返回的數組同樣是視圖，所以對切片索引的賦值操作同樣會直接反映到源數組上。
5.3 布爾型索引
布爾型索引在工作中應用的也比較多。我們先來看個例子：
In [69]: names = np.array(['bob','joe','will','bob','will','joe','joe'])
In [70]: names
Out[70]: array(['bob', 'joe', 'will', 'bob', 'will', 'joe', 'joe'], dtype='<U4')
names是一個存儲姓名的數組，下面用numpy.random中的randn函數生成一些正態分佈的隨機數據：
In [80]: from numpy import random as rd
In [81]: data = rd.randn(7,4) # 正態分佈的二維數組
In [82]: data
Out[82]: array([[ 1.28794696, -1.24441459, -1.6059525 , 0.67558219],
[ 0.3389652 , 0.46551851, -0.92335784, -0.3251096 ],
[-0.35415357, -0.49564882, 1.90609574, 0.87519881],
[ 0.04103014, -0.79487102, -0.639076 , -0.9100843 ],
[ 1.20713356, -0.75816968, -0.26561519, -1.04336953],
[ 0.35948109, -0.07867791, 0.02423479, 0.07243965],
[ 2.12471825, 1.24018587, -0.19397075, -0.780955 ]])
假設每個名字都對應data數組中的一行，而我們想要選出對應於名字'bob'的所有行,該怎麼做？
和算術運算一樣，數組的比較運算(如==)也是矢量化的，因此，對names和字符串'bob'的比較運算將會產生一個布爾型數組：
In [84]: names == 'bob'
Out[84]: array([ True, False, False, True, False, False, False])
這個布爾型數組可以用來索引：
In [85]: data[names == 'bob']
Out[85]: array([[ 1.28794696, -1.24441459, -1.6059525 , 0.67558219],
[ 0.04103014, -0.79487102, -0.639076 , -0.9100843 ]])
️布爾型數組的長度必須跟被索引的軸的長度一致。
如果需要應用多個布爾條件，使用&、|之類的布爾算術運算符即可：
In [103]: mask = (names == 'bob') | (names == 'will')
In [104]: mask
Out[104]: array([ True, False, True, True, True, False, False])
In [105]: data[mask]
Out[105]: array([[ 1.28794696, -1.24441459, -1.6059525 , 0.67558219],
[-0.35415357, -0.49564882, 1.90609574, 0.87519881],
[ 0.04103014, -0.79487102, -0.639076 , -0.9100843 ],
[ 1.20713356, -0.75816968, -0.26561519, -1.04336953]])
️Python關鍵字and和or在布爾型數組中無效。
同樣，布爾型索引可以和整數索引、切片索引混合使用：
In [87]: data[names == 'bob', 3:]
Out[87]: array([[ 0.67558219],
[-0.9100843 ]])
In [88]: data[names == 'bob', 3]
Out[88]: array([ 0.67558219, -0.9100843 ])
️整數索引是會發生降維篩選的，而切片索引和布爾索引不會。
通過布爾型數組設置值是一種經常用到的手段，爲了將data中所有的負值都設置爲0，我們只需要：
In [107]: data[data < 0] = 0
In [108]: data
Out[108]: array([[1.28794696, 0. , 0. , 0.67558219],
[0.3389652 , 0.46551851, 0. , 0. ],
[0. , 0. , 1.90609574, 0.87519881],
[0.04103014, 0. , 0. , 0. ],
[1.20713356, 0. , 0. , 0. ],
[0.35948109, 0. , 0.02423479, 0.07243965],
[2.12471825, 1.24018587, 0. , 0. ]])
5.4 花式索引
花式索引是一個NumPy的術語，它指的是利用整數數組進行索引。
舉個例子：
In [109]: arr = np.empty((8,4))
In [110]: for i in range(8):
arr[i] = i
In [111]: arr
Out[111]: array([[0., 0., 0., 0.],
[1., 1., 1., 1.],
[2., 2., 2., 2.],
[3., 3., 3., 3.],
[4., 4., 4., 4.],
[5., 5., 5., 5.],
[6., 6., 6., 6.],
[7., 7., 7., 7.]])
arr是一個8 * 4的二維數組，爲了以特定順序選取子行，只需要傳入一個用於指定順序的整數列表或ndarray即可：
In [113]: arr[[4,3,0,6]]
Out[113]: array([[4., 4., 4., 4.],
[3., 3., 3., 3.],
[0., 0., 0., 0.],
[6., 6., 6., 6.]])
使用負數索引將會從末尾開始選取行：
In [113]: arr[[-1,-2]]
Out[113]: array([[7., 7., 7., 7.],
[6., 6., 6., 6.]])
按照這樣的思路如果我們一次傳入多個整數列表是不是返回特定順序的行和列，但結果並不是這樣：
In [115]: arr = np.arange(32).reshape((8,4))
In [116]: arr
Out[116]: array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23],
[24, 25, 26, 27],
[28, 29, 30, 31]])
In [117]: arr[[3,1],[3,1]]
Out[117]: array([15, 5])
它返回的是一個一維數組，選出的元素是(3，3),(1，1)。
那怎麼才能同時選出特定順序的行和列呢？一個辦法就是使用np.ix_函數，它可以將兩個一維整數數組轉換爲一個用於方形區域的索引器：
In [118]: arr[np.ix_([3,1],[3,1])]
Out[118]: array([[15, 13],
[ 7, 5]])
這就對了，還有另外一種方法：
In [118]: arr[[3,1]][:,[3,1]]
Out[118]: array([[15, 13],
[ 7, 5]])
6.通用函數
ufunc(通用函數)是一種對ndarray中的數據執行元素級運算的函數。
舉幾個例子：
In [123]: arr = np.arange(12).reshape(3,4)
In [124]: arr
Out[124]: array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In [125]: np.sqrt(arr) # 計算各元素的平方根
Out[125]: array([[0. , 1. , 1.41421356, 1.73205081],
[2. , 2.23606798, 2.44948974, 2.64575131],
[2.82842712, 3. , 3.16227766, 3.31662479]])
In [126]: np.square(arr) # 計算各元素的平方
Out[126]: array([[ 0, 1, 4, 9],
[ 16, 25, 36, 49],
[ 64, 81, 100, 121]])
以上都是一元ufunc,另外一寫ufunc接收2各數組(因此也叫做二元ufunc)，並返回一個新數組：
In [127]: from numpy import random as rd
In [128]: arr1 = rd.randn(4) # 正態分佈的一維數組
In [129]: arr1
Out[129]: array([0.20687398, 0.81274684, 0.27283635, 0.23128059])
In [130]: arr2 = rd.randn(4) # 正態分佈的一維數組
In [131]: arr2
Out[131]: array([ 0.6324182 , -2.02399605, -0.84640293, -1.03594909])
In [132]: np.maximum(arr1, arr2) # 元素級最大值
Out[132]: array([0.6324182 , 0.81274684, 0.27283635, 0.23128059])
一些一元ufunc:
| 函數 | 說明 |
|---|---|
| abs、fabs | 計算整數、浮點數或複數的絕對值。對於非複數值，可以使用更快的fabs |
| sqrt | 計算各元素的平方根。相當於arr**0.5 |
| square | 計算各元素的平方。相當於arr**2 |
| exp | 計算各元素的指數e^x |
| log、log10、log2、log1p | 分別爲自然對數(底數爲e)、底數爲10的log、底數爲2的log、log(1+x) |
| sign | 計算各元素的正負號：1(正數)、0(零)、-1(負數) |
| ceil | 計算各元素的ceiling值，即大於等於該值的最小整數 |
| floor | 計算各元素的floor值，即小於等於該值的最大整數 |
| rint | 將各元素值四捨五入到最接近的整數，保留dtype |
| isnan | 返回一個表示“哪些值是NaN”的布爾型數組 |
️更多一元和二元ufunc請參考官網。
7.利用數組進行數據處理
NumPy數組使你可以將多種數據處理任務表述爲簡潔的數組表達式。用數組表達式代替循環的做法，通常被稱爲 矢量化。
7.1 將條件邏輯表達爲數組運算
numpy.where函數是三元表達式x if condition else y的矢量化版本。
看個例子：
In [133]: xarr = np.array([1.1,1.2,1.3,1.4,1.5])
In [134]: xarr
Out[134]: array([1.1, 1.2, 1.3, 1.4, 1.5])
In [135]: yarr = np.array([2.1,2.2,2.3,2.4,2.5])
In [136]: yarr
Out[136]: array([2.1, 2.2, 2.3, 2.4, 2.5])
In [137]: cond = np.array([True,False,True,True,False])
In [138]: cond
Out[138]: array([ True, False, True, True, False])
如果我們想要根據cond的值選取xarr和yarr的值：當cond爲True時，選取xarr的值，否則從yarr中選取。使用循環比較繁瑣且對於大數組的處理速度不是很快。若使用np.where則可以簡寫爲：
In [138]: result = np.where(cond, xarr, yarr)
In [138]: result
Out[138]: array([1.1, 2.2, 1.3, 1.4, 2.5])
np.where的第二個和第三個參數不必是數組，它們都可以是標量值。例如在數據分析中，where通常用於根據一個數組產生一個新的數組。假設有一個由隨機數組成的矩陣，你希望將所有正值替換爲2，將所有負值替換爲-2。若利用np.where則會變得非常簡單：
In [141]: from numpy import random as rd
In [142]: arr = rd.randn(4,4)
In [143]: arr
Out[143]: array([[ 0.50943315, 0.86730205, -0.58578168, 0.07091693],
[ 0.10816702, 1.49343972, 0.81776697, 0.81133719],
[-0.01395082, -1.38688598, -0.13255509, 0.5381726 ],
[ 1.12388897, 0.67390186, -0.5794577 , -0.41228758]])
In [144]: np.where(arr > 0, 2, -2) # 正數改爲2，負數改爲-2
Out[144]: array([[ 2, 2, -2, 2],
[ 2, 2, 2, 2],
[-2, -2, -2, 2],
[ 2, 2, -2, -2]])
In [146]: np.where(arr > 0, 2, arr) # 只將正數改爲2
Out[146]: array([[ 2. , 2. , -0.58578168, 2. ],
[ 2. , 2. , 2. , 2. ],
[-0.01395082, -1.38688598, -0.13255509, 2. ],
[ 2. , 2. , -0.5794577 , -0.41228758]])
7.2 數學和統計方法
可以通過數組上的一組數學函數對整個數組或某個軸向的數據進行聚合統計計算。
In [147]: arr = np.arange(12).reshape(3,4)
In [148]: arr
Out[148]: array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In [149]: arr.mean() # 算術平均數
Out[149]: 5.5
In [150]: arr.sum() # 求和
Out[150]: 66
mean和sum這類的函數還可以接收一個axis參數(用於計算該軸向上的統計值)：
In [153]: arr.sum(axis = 1) # 1代表二維數組中行軸
Out[153]: array([ 6, 22, 38])
In [153]: arr.sum(axis = 0) # 0代表二維數組中列軸
Out[153]: array([12, 15, 18, 21])
下表列出了全部的基本數組統計方法。
| 方法 | 說明 |
|---|---|
| sum | 對數組中全部或某軸向的元素求和。零長度的數組的sum爲0 |
| mean | 算術平均數。零長度的數組的mean爲NaN |
| std、var | 分別爲標準差和方差，自由度可調 |
| min、max | 最大值和最小值 |
| argmin、argmax | 分別爲最大和最小元素的索引 |
| cumsum | 所有元素的累計和 |
| sumprod | 所有元素的累計積 |
7.3 用於布爾型數組的方法
在上面的這些方法中，布爾值會被強制轉換爲1(True)和0(False)。因此，sum經常被用來對布爾型數組中的True值計數：
In [156]: arr = rd.randn(2,5) # 正態分佈的二維數組數據
In [157]: arr
Out[157]: array([[ 0.25634557, 0.4367522 , -1.41156838, -0.43382141, -0.14254968],
[-1.45358166, -1.77782062, 0.84003744, -0.11864763, -0.26476296]])
In [158]: (arr > 0).sum() # 正值的數量
Out[158]: 3
這裏的sum函數爲什麼就不是求和呢？其實是有道理的，因爲arr > 0結果是一個布爾型數組啊，布爾類型的值怎麼求和嘛，對不對。
另外還有兩個方法any和all，它們對布爾類型數組非常有用。any用於檢查數組中是否存在一個或多個True,而all檢查數組中所有的值是否都是True。
舉個例子：
In [160]: from numpy import nan as NaN
In [161]: arr = np.array([[1,2,3,4],[5,6,7,NaN]]) # nan代表空值
In [162]: arr
Out[162]: array([[ 1., 2., 3., 4.],
[ 5., 6., 7., nan]])
我們想檢測arr中有沒有空值，則可以這樣做：
In [168]: np.isnan(arr).any() # isnan函數是一個ufunc，返回一個布爾型數組
Out[168]: True
這兩個方法也能用於非布爾型數組，所有非0元素都將被當成True。
7.4 排序
跟Python內置的列表類型一樣，NumPy數組也可以通過sort方法就地排序：
In [182]: from numpy import random as rd
In [183]: arr = rd.randn(5) # 正態分佈的一維數組
In [184]: arr
Out[184]: array([0.76144187, 0.92518998, 1.74213039, 0.8244198 , 1.33964152])
In [185]: arr.sort() # 升序排序
In [186]: arr
Out[186]: array([0.76144187, 0.8244198 , 0.92518998, 1.33964152, 1.74213039])
多維數組可以在任何一個軸向上進行排序，只需將軸編號傳給sort即可：
In [198]: arr = rd.randn(3,3) # 正態分佈的二維數組
In [199]: arr
Out[199]: array([[-1.09501091, 0.33296923, -0.4430025 ],
[-0.04355405, -0.61911744, -0.65246943],
[-0.38652144, -0.74480079, 0.32569722]])
In [200]: arr.sort(0) # 0代表的是列軸，不寫默認也是0，1代表的是行軸
In [201]: arr
Out[201]: array([[-1.09501091, -0.74480079, -0.65246943],
[-0.38652144, -0.61911744, -0.4430025 ],
[-0.04355405, 0.33296923, 0.32569722]])
7.5 去重以及其他集合邏輯
NumPy提供了一些針對一維ndarray的基本邏輯運算。最常用的可能要數np.unique，它用於找出數組中的唯一值並返回以排序的結果：
In [202]: names = np.array(['bob','joe','will','bob','will','joe','joe'])
In [203]: np.unique(names)
Out[203]: array(['bob', 'joe', 'will'], dtype='<U4')
NumPy中的集合函數請參見下表：
| 方法 | 說明 |
|---|---|
| unique(x) | 計算x中的唯一元素，並返回有序結果 |
| intersect1d(x,y) | 計算x和y中的公共元素，並返回有序結果 |
| union1d(x,y) | 計算x和y的並集，並返回有序結果 |
| in1d(x,y) | 得到一個表示“x的元素是否包含於y” |
| setdiff1d(x,y) | 集合的差，即元素在x中且不在y中 |
| setxor1d(x,y) | 集合的對稱差，即存在於一個數組中但不同時存在於兩個數組中的元素 |
8. 輸入輸出
NumPy能夠讀寫磁盤上的文本數據或二進制數據。其實運用更多的是Pandas中的讀取磁盤數據到內存。
8.1 將數組以二進制格式保存到磁盤
numpy.save和np.load是讀寫磁盤數組數據的兩個主要函數。
In [204]: arr = arr = np.arange(10).reshape(2,5)
In [205]: np.save('ndarray',arr)
默認情況下，數組是爲壓縮的原始二進制格式保存在擴展名爲.npy的文件中的。
[appl@SZVM-EXlOIT-1-243 dongzhongwei]$ cd numpy_exercises/
[appl@SZVM-EXlOIT-1-243 numpy_exercises]$ ls -l
總用量 44
-rw-r----- 1 appl fspfappl 152 1月 9 20:51 ndarray.npy
-rw-r----- 1 appl fspfappl 39378 1月 9 20:52 Untitled.ipynb
如果文件路徑末尾沒有擴展名.npy，則該擴展名會被自動加上。然後就可以通過np.load讀取磁盤上的數組：
In [205]: np.load('ndarray.npy')
Out[205]: array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
8.2 存取文本文件
存文本文件：
In [206]: np.savetxt('ndarray.txt', arr, delimiter= ',')
[appl@SZVM-EXlOIT-1-243 numpy_exercises]$ cat ndarray.txt
0.000000000000000000e+00,1.000000000000000000e+00,2.000000000000000000e+00,3.000000000000000000e+00,4.000000000000000000e+00
5.000000000000000000e+00,6.000000000000000000e+00,7.000000000000000000e+00,8.000000000000000000e+00,9.000000000000000000e+00
加載文本文件：
In [207]: arr = np.loadtxt('ndarray.txt', delimiter= ',')
In [208]: arr
Out[208]: array([[0., 1., 2., 3., 4.],
[5., 6., 7., 8., 9.]])
️更多有關文件讀寫的知識，請參閱後續有關Pandas的文章。