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])

如今檢查一下，索引一、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

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

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

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