作者|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庫或計劃將來使用，或正在學習，此頁面可以成為你日常生活的一個很好的資源。

這里將討論以下主題：

Numpy數組基礎知識

重復

數學運算

統計

初始化不同類型的數組

重新排列或重新組織數組

數組的索引與切片

添加行或列

追加、插入、刪除和排序

隨機

文件導入、保存和加載

我們開始吧！！

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 = np.genfromtxt('Cartwheeldata.csv', delimiter=',') filedata=filedata.astype('int32') filedata

輸出：

我在這里展示數組的一部分。因為文件很大。所以，這是關于那個文件的部分信息。

這些類型的數組在機器學習中非常有用。

結論

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

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

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的numpy 平方_Numpy的终极备忘录的全部內容，希望文章能夠幫你解決所遇到的問題。

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