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

這裏將討論以下主題：

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

輸出：

輸入：

b.ndim

輸出：

數組“a”是一維數組，數組b是二維數組。

現在，找出數組“a”和“b”的形狀：

輸入：

a.shape

輸出：

(3,)

輸入：

b.shape

輸出：

(2, 3)

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

查找數組的長度：

輸入：

len(a)

輸出：

輸入：

len(b)

輸出：

數組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)

輸出：

什麼是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()

輸出：

輸入：

x.max()

輸出：

輸入：

x.min()

輸出：

-3

輸入：

x.mean()

輸出：

1.5

輸入：

x.std()  # 標準差

輸出：

3.2015621187164243

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

輸入：

x.argmin()

輸出：

輸入：

x.argmax()

輸出：

什麼是“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]

輸出：

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

輸入：

a[3]

輸出：

我們也可以切片，

輸入：

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)

輸出：

它產生了一個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

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

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

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

Numpy的終極備忘錄

什麼是Numpy

Numpy數組基礎知識

查找數組的長度：

重複

數學運算

統計

初始化不同類型的數組

重新排列或重新組織數組

索引或切片

添加行或列

連接

追加、插入、刪除和排序

隨機

保存、加載和導入文件

結論

Numpy的終極備忘錄

監督學習和kNN分類初學者教程

用PyTorch實現圖像聚類

Pandas概論

掌握Python字典的12個例子

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結