Numpy的終極備忘錄

作者|Rashida Nasrin Sucky
編譯|VK
來源|Towards Data Science

Python是開源的，對于使用python的資料科學家來說，Numpy這個庫是必不可少的，其他一些基本的庫，如Pandas，Scipy是建立在Numpy的基礎上，所以我決定做一份備忘錄，這里我包括了到目前為止使用的所有Numpy函式，我相信這些函式將足以讓你在日常作業中作為資料科學家或資料分析員完成你的作業，

我將從非常基本的Numpy功能開始，慢慢地向更高級的功能移動，但是使用Numpy很容易，在這里你不會發現任何復雜的編碼技巧，

什么是Numpy

在Numpy檔案中，Numpy的定義如下：

NumPy是Python中科學計算的基本包，它是一個Python庫，它提供多維陣列物件、各種派生物件(如掩碼陣列和矩陣)以及陣列上快速操作的各種例程，包括數學、邏輯、形狀處理、排序、選擇、I/O、離散傅立葉變換、基本線性代數，基本的統計操作，隨機模擬等等，

我每天都用這個庫，如果是python用戶，大多數資料科學家都會這么做，它快速，易于使用，理解，簡單，我不想寫太多關于它是如何和為什么這么好的，因為在閱讀本文的程序中，你將親眼看到這一點，

我的目標是記錄Numpy每天使用的方法，

正如文章名所說，這是一本關于Numpy的指南，它也可以用作備忘錄，如果你使用Numpy庫或計劃將來使用，或正在學習，此頁面可以成為你日常生活的一個很好的資源，

這里將討論以下主題：

1. Numpy陣列基礎知識

2. 重復

3. 數學運算

4. 統計

5. 初始化不同型別的陣列

6. 重新排列或重新組織陣列

7. 陣列的索引與切片

8. 添加行或列

9. 追加、插入、洗掉和排序

10. 隨機

11. 檔案匯入、保存和加載

我們開始吧！！

Numpy陣列基礎知識

整個練習我都用了一個Jupyter Notebook，第一個匯入Numpy，

import numpy as np

做一個Numpy陣列，為此，我們需要傳遞一個Python串列，

輸入：

a = np.array([1,2,3])
a

輸出：

array([1, 2, 3])

在陣列'a'中，我使用了所有的整數，現在，制作一個浮點陣列：

輸入：

b = np.array([[9.0, 10.0, 6.0], [6.0,1.0,7.0]])
b

輸出：

array([[ 9., 10.,  6.],
       [ 6.,  1.,  7.]])

讓我們試著用浮點型和浮點型陣列：

輸入：

np.array([1, 3.0, 0.004, -2])

輸出：

array([ 1.   ,  3.   ,  0.004, -2.   ])

注意，Numpy自動將整數轉換為浮點！

找出陣列a和b的尺寸：

輸入：

a.ndim

輸出：

1

輸入：

b.ndim

輸出：

2

陣列“a”是一維陣列，陣列b是二維陣列，

現在，找出陣列“a”和“b”的形狀：

輸入：

a.shape

輸出：

(3,)

輸入：

b.shape

輸出：

(2, 3)

陣列“a”是一維陣列，它只有一個值，但是陣列b是一個二維陣列，所以，它的形狀是2×3，這意味著它有2行3列，

查找陣列的長度：

輸入：

len(a)

輸出：

3

輸入：

len(b)

輸出：

2

陣列a的長度是3，因為它里面有3個元素，陣列“b”是一個二維陣列，因此，陣列的長度并不意味著其中元素的數量，長度表示其中一維陣列的數量或其中的行數，它有兩行，長度是2，

重復

有幾種不同的方法可以重復陣列的元素，如果你想重復整個陣列，

輸入：

np.array([2,4,6]*4)

輸出：

array([2, 4, 6, 2, 4, 6, 2, 4, 6, 2, 4, 6])

看，陣列[2，4，6]被重復了4次，

下面是如何做元素級的重復，

輸入：

np.repeat([1,2,3], 3)

輸出：

array([1, 1, 1, 2, 2, 2, 3, 3, 3])

這次每個元素重復3次，

我們把這個用于二維陣列，

輸入：

arr = np.array([[2, 4, 6]])
arr

輸出：

array([[2, 4, 6]])

現在，在它上面重復：

輸入：

np.repeat(arr,3,axis=0)

輸出：

array([[2, 4, 6],
       [2, 4, 6],
       [2, 4, 6]])

這里，我們提到axis=0，所以，重復發生在0軸方向或行方向，

輸入：

np.repeat(arr,3,axis=1)

輸出：

array([[2, 2, 2, 4, 4, 4, 6, 6, 6]])

軸1指示列的方向，所以，重復發生在列的方向上，

數學運算

在這一節中，我將展示數學運算，大多數操作都是不言而喻的，我將從一個陣列的數學運算開始，

輸入：

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

輸出：

array([1, 2, 3, 4])

輸入：

a+2

輸出：

array([3, 4, 5, 6])

它向陣列的每個元素添加2，

輸入：

a-2

輸出：

array([-1,  0,  1,  2])

你可以簡單地使用類似的操作，例如：

輸入：

a/2

輸出：

array([0.5, 1. , 1.5, 2. ])

輸入：

a**2

輸出：

array([ 1,  4,  9, 16], dtype=int32)

兩個星號表示指數，“a”中的每個元素都是平方的，

輸入：

np.sqrt(a)  # 平方根

輸出：

array([1.        , 1.41421356, 1.73205081, 2.        ])

我們還可以執行一些三角運算：

輸入：

np.cos(a)

輸出：

array([ 0.54030231, -0.41614684, -0.9899925 , -0.65364362])

輸入：

np.sin(a)

輸出：

array([ 0.84147098,  0.90929743,  0.14112001, -0.7568025 ])

輸入：

np.tan(a)

輸出：

array([ 1.55740772, -2.18503986, -0.14254654,  1.15782128])

現在看看我們如何在兩個陣列或矩陣中做一些數學運算，首先，再做一個陣列，

輸入：

b = np.array([3,4,5,6])

輸出：

array([3, 4, 5, 6])

作為提醒，我們的陣列“a”如下所示：

array([1, 2, 3, 4])

現在，我們有兩個陣列，a和b，讓我們做同樣的數學運算，再說一次，這很簡單，不言自明，

輸入：

a + b

輸出：

array([ 4,  6,  8, 10])

你可以用同樣的方法進行以下操作：

a - b
a*b
a/b
a**b

另一種廣泛使用的操作是，

輸入：

a.dot(b)

輸出：

50

什么是a.dot(b)？這是先應用元素的乘法，然后再進行累加，

1*3 + 2*4 + 3*5 + 4*6

其中陣列“a”是[1,2,3,4]，陣列b是[3,4,5,6]，

你也可以寫一些不同的語法，

np.dot(a, b)

這是一樣的，輸出將是50，

我們可以在多維陣列中使用這個程序，我們做兩個多維陣列，

輸入：

c = np.array([[3, 5, 1], [6, 4, 9]])
c

輸出：

array([[3, 5, 1],
       [6, 4, 9]])

輸入：

d = np.array([[5,2], [7,9], [4, 3]])
d

輸出：

array([[5, 2],
       [7, 9],
       [4, 3]])

我們準備好在多維陣列上進行“點”運算，

輸入：

c.dot(d)

輸出：

array([[54, 54],
       [94, 75]])

當輸入為二維陣列時，“點”函式的行為類似于矩陣乘法，

這意味著你只能在第一個陣列的列數與第二個陣列中的行數匹配時執行“點”操作，

如果第一個陣列是mxn，那么第二個陣列應該是nxp，

矩陣乘法還有另一個運算式，

輸入：

np.matmul(c, d)

輸出：

array([[54, 54],
       [94, 75]])

‘np.matmul'在一維陣列中不起作用

記住，這個乘法規則不適用于其他運算，如加法、減法或除法，我們需要有相同形狀和大小的陣列來對一個矩陣進行加法、減法或除法，

統計

Numpy也有基本的統計操作，這里有一些例子，

首先創建一個新陣列，

輸入：

x = np.array([1,3,4,6,-3,-2])
x.sum()

輸出：

9

輸入：

x.max()

輸出：

6

輸入：

x.min()

輸出：

-3

輸入：

x.mean()

輸出：

1.5

輸入：

x.std()  # 標準差

輸出：

3.2015621187164243

還有另外兩個非常有用的函式，它們不是完全統計的，

輸入：

x.argmin()

輸出：

4

輸入：

x.argmax()

輸出：

3

什么是“argmin()”或“argmax()”？

“argmin()”提供陣列最小元素的索引，“argmax()”回傳陣列最大值的索引，

陣列“x”的最小元素是-3，陣列“x”的最大元素是6，可以檢查他們的索引是否匹配，

初始化不同型別的陣列

Numpy中有很多不同的方法來初始化陣列，這里我將討論一些常用的方法：

輸入：

np.arange(10)

輸出：

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

這是初始化一系列數字的方法，注意它從0開始到9結束，始終排除上限，這里的上限是10，所以，它在9停止，

我們還可以添加一個數學運算：

輸入：

np.arange(10)**2

輸出：

array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)

在本例中，我們要求平方，我們得到了輸出陣列中0到9的平方，

我們可以用一定的間隔把一系列的數字組成一個陣列，

np.arange(0, 15, 3)

輸出：

array([ 0,  3,  6,  9, 12])

這里，0是下限，15是上限，3是間隔，

還有另一種方法可以提供稍微不同的序列：

輸入：

np.linspace(0, 3, 15)

輸出：

array([0.        , 0.21428571, 0.42857143, 0.64285714, 0.85714286,
       1.07142857, 1.28571429, 1.5       , 1.71428571, 1.92857143,
       2.14285714, 2.35714286, 2.57142857, 2.78571429, 3.        ])

這里的元素數是0，上限是3，在本例中，Numpy自動生成15個元素，這些元素的間距從0到3相等，

還有幾種其他型別的陣列：

輸入：

np.ones((3, 4))

輸出：

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

輸入：

np.zeros((2, 3))

輸出：

array([[0., 0., 0.],
       [0., 0., 0.]])

你可以得到一個三維陣列：

輸入：

np.ones((4,3,2), dtype='int32')

輸出：

array([[[1, 1],
        [1, 1],
        [1, 1]],[[1, 1],
        [1, 1],
        [1, 1]],[[1, 1],
        [1, 1],
        [1, 1]],[[1, 1],
        [1, 1],
        [1, 1]]])

這里，(4,3,2)表示4個二維陣列，每個陣列有3行2列，

還有另一種方法叫做full，它可以替換陣列的元素：

輸入：

np.full((2,2), 30)

輸出：

array([[30, 30],
       [30, 30]])

輸入：

ar = np.array([[2,3], [4,5]])
ar

輸出：

array([[2, 3],
       [4, 5]])

輸入：

np.full_like(ar, 4)

輸出：

array([[4, 4],
       [4, 4]])

還有另一種型別的矩陣稱為單位矩陣：

輸入：

np.identity(5)

輸出：

array([[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.]])

這是一個5x5的矩陣，只有對角元素是1，其他元素都是0，

還有一種型別叫做“eye”，它的引數是矩陣的形狀：

輸入：

np.eye(3,3)

輸出：

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

輸入：

np.eye(3,4)

輸出：

array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.]])

對角線上的數字可以不同于1，

輸入：

a = np.array([2,4,5])
np.diag(a)

輸出：

array([[2, 0, 0],
       [0, 4, 0],
       [0, 0, 5]])

重新排列或重新組織陣列

有不同的方法來重新排列或組織陣列，

首先，做一個陣列，

輸入：

x = np.arange(0, 45, 3)
x

輸出：

array([ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42])

我在上一節中解釋了“arange”函式，讓我們看看如何重塑它，

輸入：

x.reshape(3, 5)

輸出：

array([[ 0,  3,  6,  9, 12],
       [15, 18, 21, 24, 27],
       [30, 33, 36, 39, 42]])

我們傳入了(3，5)，因此，它變成了一個有3行5列的二維陣列，我們可以通過使用：

x.resize(3,5)

如果我們想回到原來的一維陣列呢？

這是方法之一

輸入：

x.ravel()

輸出：

array([ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42])

看，我們找回了原來的陣列！

注意另一件事，我們改變了陣列的維數，陣列“x”是一維陣列，我們通過重塑它使它成為一個二維陣列，

現在，制作另一個陣列來更好地理解它，這是另一個例子，

輸入：

c = np.array([4,5,6])
c

輸出：

array([4, 5, 6])

這次我將使用resize，“reshape”也會這樣做，為了練習調整大小，讓我們在這里使用resize，

輸入：

c.resize(3,1)

輸出：

array([[4],
       [5],
       [6]])

我們提供了(3,1)作為調整大小的引數，所以它有3行1列，這是一個3x1矩陣，我們也可以有一個1x3矩陣，

輸入：

c.resize(1,3)
c

輸出：

array([[4, 5, 6]])

原來c是一維陣列，或者現在是二維矩陣，

不要認為你只能重塑一個一維陣列的大小，也可以在高維陣列中執行此操作，

我舉幾個例子：

輸入：

x = np.array([[1,2,3,4], [5,6,7,8]])
x

輸出：

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

現在重塑這個二維陣列，

輸入：

x.reshape(4,2)
x

輸出：

array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

你可以使用我前面提到的“resize”來實作這一點，還有另一種方法，

輸入：

y = x.reshape(4, -1)
y

輸出：

array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

看起來很困惑？想象一下，你有一個巨大的陣列或資料集，在重塑之前，你只知道一個維度，因此，在reshape方法中，給出了其他維的大小，剩下的numpy可以自己計算，

在上面的例子中，我傳遞了第一個維度4，這意味著我要讓Numpy做4行，我不知道有多少列，所以我就設定引數-1，所以，它會自動生成2列，

當我們處理大資料集或資料幀時，這是一個非常有用的技巧，我們必須構建機器學習演算法，

在上面的所有例子中，我們看到了如何重塑和改變尺寸，

這是改變尺寸的方法，上面的陣列“y”是一個4x2矩陣，讓我們再做一個2x4矩陣，

輸入：

y.T

輸出：

array([[1, 3, 5, 7],
       [2, 4, 6, 8]])

這種方法稱為轉置，當你在陣列或矩陣上使用轉置時，它只是改變了維數，2x3矩陣變為3x2，3x6矩陣變為6x3或1x3矩陣變為3x1，

索引或切片

索引和切片是一項非常常見的日常任務，我們來舉幾個例子：

輸入：

a = np.array([2,5,1,7,6,3,9,0,4])

輸入：

a[0]

輸出：

2

a[0]給出陣列的第一個元素，同樣，我們可以繼續使用a[1]，a[2]，一直到整個陣列，

輸入：

a[3]

輸出：

7

我們也可以切片，

輸入：

a[1:5]

輸出：

array([5, 1, 7, 6])

我們輸入了[1:5]，因此，切片將從索引1開始，在索引5之前結束，記住，包括下限，排除上限，

在本文中，我不再深入討論切片和索引，因為我已經寫了另一篇文章詳細解釋過了，請檢查一下，學好它很重要，

https://towardsdatascience.com/indexing-and-slicing-of-1d-2d-and-3d-arrays-in-numpy-e731afff0bbe

添加行或列

Numpy有幾種不同的方法來添加行或列，這里有一些例子，

這次我將使用一些串列或陣列，Numpy會在堆疊時自動將它們變成陣列，

這里有兩個串列：

x1 = [[2, 4, 3, 7], [2, 5, 3, 1]]
x2 = [1, 0, 9, 5]

現在垂直堆疊它們，

輸入：

np.vstack([x1, x2])

輸出：

array([[2, 4, 3, 7],
       [2, 5, 3, 1],
       [1, 0, 9, 5]])

你可以把它們疊成你想要的次數，

輸入：

np.vstack([x1, x2, x2])

輸出：

array([[2, 4, 3, 7],
       [2, 5, 3, 1],
       [1, 0, 9, 5],
       [1, 0, 9, 5]])

讓我們做一些水平堆疊，我們需要行數相同的陣列，

“x1”有2行，用它做一個陣列，

輸入：

np.array(x1)

輸出：

array([[2, 4, 3, 7],
       [2, 5, 3, 1]])

生成另一個陣列“x3”，

輸入：

x3 = np.ones((2,3))
x3

輸出：

array([[1., 1., 1.],
       [1., 1., 1.]])

水平堆疊

輸入：

np.hstack([x1, x3])

輸出：

array([[2., 4., 3., 7., 1., 1., 1.],
       [2., 5., 3., 1., 1., 1., 1.]])

連接

另一種添加列或行的方法，但與堆疊相反，這次我們需要兩個相同維度的陣列，記住，當我們進行垂直堆疊時，我們有一個二維和一維串列，

這是我在這個例子中的兩個串列，

x1 = [[2, 4, 3, 7], [2, 5, 3, 1]]
x2 = [[1, 0, 9, 5]]

concatenate操作

輸入：

np.concatenate((x1, x2), axis=0)

輸出：

array([[2, 4, 3, 7],
       [2, 5, 3, 1],
       [1, 0, 9, 5]])

現在，水平連接，但我們需要兩個行數相同的陣列，

x3 = [[2,4], [7,5]]

連接x1和x3，

輸入：

np.concatenate((x1, x3), axis=1)

輸出：

array([[2, 4, 3, 7, 2, 4],
       [2, 5, 3, 1, 7, 5]])

追加、插入、洗掉和排序

你可能知道這些行動的函式，

append

輸入：

np.append([2,3], [[4,5], [1, 3]])

輸出：

array([2, 3, 4, 5, 1, 3])

輸入：

np.append([2, 3, 1], [[4, 5], [1,3]])

輸出：

array([2, 3, 1, 4, 5, 1, 3]

我們在這些例子中沒有提到任何軸心，所以，默認情況下，它們取軸1，或者在列方向或水平方向，現在，在垂直方向執行追加操作，

輸入：

np.append([[1,3,5], [4,3,6]], [[1,2,3]], axis=0)

輸出：

array([[1, 3, 5],
       [4, 3, 6],
       [1, 2, 3]])

Insert

這次我們將在某個位置插入一個元素，從一個新陣列開始，

輸入：

a = np.array([[2, 2], [3, 4], [5, 6]])
a

輸出：

array([[2, 2],
       [3, 4],
       [5, 6]])

在陣列的開頭插入元素5，

輸入：

np.insert(a, 0, 5)

輸出：

array([5, 2, 2, 3, 4, 5, 6])

首先，理解輸入，在(a，0，5)中，a是陣列，0是要插入元素的位置，5是要插入的元素，

注意，插入是如何發生的，首先，二維陣列a被展平成一維陣列，然后在索引0處添加5，

我們也可以沿著軸插入，

輸入：

np.insert(a, 0, 5, axis=1)

輸出：

array([[5, 2, 2],
       [5, 3, 4],
       [5, 5, 6]])

看，一列5被添加到陣列'a'中，我們也可以添加一行5，

輸入：

np.insert(a, 0, 5, axis=0)

輸出：

array([[5, 5],
       [2, 2],
       [3, 4],
       [5, 6]])

Delete

我會像以前一樣做一個新的陣列，

輸入：

a= np.array([[1,3,2,6], [4,1,6,7], [9, 10, 6, 3]])
a

輸出：

array([[ 1,  3,  2,  6],
       [ 4,  1,  6,  7],
       [ 9, 10,  6,  3]])

輸入：

np.delete(a, [1, 2, 5])

輸出：

array([ 1,  6,  4,  6,  7,  9, 10,  6,  3])

與插入操作一樣，洗掉操作也會使陣列變平，在輸入[1,2,5]中是要洗掉的索引串列，為了清楚地看到它，讓我們展平原始陣列'a'，

輸入：

a.flatten()

輸出：

array([ 1,  3,  2,  6,  4,  1,  6,  7,  9, 10,  6,  3])

現在檢查一下，索引1、2和5的元素都被洗掉了，

與插入類似，我們可以洗掉特定的行或列，

洗掉列索引1，

輸入：

np.delete(a, 1, 1)

輸出：

array([[1, 2, 6],
       [4, 6, 7],
       [9, 6, 3]])

在輸入(a，1，1)中，a是陣列，1是要洗掉的列的索引，最后一個1是軸，

輸入：

np.delete(a, 1, 0)

輸出：

array([[ 1,  3,  2,  6],
       [ 9, 10,  6,  3]])

Sort

陣列“a”：

array([[ 1,  3,  2,  6],
       [ 4,  1,  6,  7],
       [ 9, 10,  6,  3]])

輸入：

np.sort(a)

輸出：

array([[ 1,  2,  3,  6],
       [ 1,  4,  6,  7],
       [ 3,  6,  9, 10]])

看，它是雙向排列的，我們可以指定軸并按特定軸排序，

輸入：

np.sort(a, axis=None)

輸出：

array([ 1,  1,  2,  3,  3,  4,  6,  6,  6,  7,  9, 10])

當軸為“None”時，它展平陣列并進行排序，現在，按軸0和軸1排序，

輸入：

np.sort(a, axis=0)

輸出：

array([[ 1,  1,  2,  3],
       [ 4,  3,  6,  6],
       [ 9, 10,  6,  7]])

輸入：

np.sort(a, axis=1)

輸出：

array([[ 1,  2,  3,  6],
       [ 1,  4,  6,  7],
       [ 3,  6,  9, 10]])

Flip

它確實像聽起來那樣，翻轉陣列和行，

這是該陣列，

arr

輸出：

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

現在，沿軸0和1的方向翻轉該陣列，

輸入：

np.flip(arr, 0)

輸出：

array([[ 9, 10, 11, 12],
       [ 5,  6,  7,  8],
       [ 1,  2,  3,  4]])

輸入：

np.flip(arr, 1)

輸出：

array([[ 4,  3,  2,  1],
       [ 8,  7,  6,  5],
       [12, 11, 10,  9]])

隨機

Numpy有很好的亂數生成功能，它們在機器學習、研究或統計方面非常有用，這里有一些例子，

輸入：

np.random.rand()

輸出：

0.541670003513435

它生成一個介于0到1之間的數字，我們可以從這樣的亂數中得到一個陣列或矩陣，

輸入：

np.random.rand(3)

輸出：

array([0.6432591 , 0.78715203, 0.81071309])

輸入：

np.random.rand(2, 3)

輸出：

array([[0.91757316, 0.74438045, 0.85259742],
       [0.19826903, 0.84990728, 0.48328816]])

它不一定是從0到1的數字，我們可以生成隨機整數，

輸入：

np.random.randint(25)

輸出：

20

它產生了一個0到25范圍內的亂數，我們可以指定要生成多少個數字，

輸入：

np.random.randint(1, 100, 10)

輸出：

array([96, 44, 90, 13, 47, 16,  9, 46, 49, 20])

在這里，我們要求Numpy生成10個介于1到100之間的數字，

現在，生成1到100范圍內的3x3矩陣，

輸入：

np.random.randint(1, 100, (3,3))

輸出：

array([[25, 80, 42],
       [95, 82, 66],
       [64, 95, 55]])

你可以提供一個陣列，并要求Numpy使用你提供的陣列中的數字生成一個3x3矩陣，而不是一個范圍，

輸入：

np.random.choice([1,2,3,4,5,6,7,8,9,10], size=(3,3))

輸出：

array([[ 7,  9,  2],
       [ 6,  4,  6],
       [ 3, 10,  6]])

另一個有用的函式是“shuffle”，讓我們做一個新的陣列并進行shuffle，

輸入：

a = np.array([3,6,3,1,0, 11])
np.random.shuffle(a)
a

輸出：

array([ 3,  0,  6,  3, 11,  1])

聽著，我們有相同的元素，只是在shuffle后重新排列，

保存、加載和匯入檔案

我們可以將陣列“arr”保存在一個檔案中，

輸入：

np.save('arrfile', arr)

這里，我們正在生成一個名為“arrfile”的檔案來保存陣列“arr”，檔案將以“.npy”擴展名保存，

我們可以加載該檔案并將其帶回來繼續使用該陣列，

輸入：

np.load('arrfile.npy')

輸出：

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

我們可以使用Numpy作為陣列匯入CSV檔案或文本檔案，我在Jupyter Notebook相同的檔案夾中有一個名為'Cartwheeldata.csv“，我撰寫了這些示例，現在，在這里匯入該檔案，

輸入：

filedata = https://www.cnblogs.com/panchuangai/p/np.genfromtxt('Cartwheeldata.csv', delimiter=',')
filedata=https://www.cnblogs.com/panchuangai/p/filedata.astype('int32')
filedata

輸出：

我在這里展示陣列的一部分，因為檔案很大，所以，這是關于那個檔案的部分資訊，

這些型別的陣列在機器學習中非常有用，

結論

這就是我想在本文中分享的所有Numpy函式，Numpy是個大庫，它有很多可用的方法，但是這些函式應該足夠適合日常使用，

原文鏈接：https://towardsdatascience.com/an-ultimate-cheat-sheet-for-numpy-bb1112b0488f

歡迎關注磐創AI博客站：
http://panchuang.net/

sklearn機器學習中文官方檔案：
http://sklearn123.com/

歡迎關注磐創博客資源匯總站：
http://docs.panchuang.net/

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/227326.html

標籤：其他

上一篇：樸素貝葉斯分類-理論篇-如何通過概率解決分類問題

下一篇：chosen插件下拉打開后自動滾動問題求助