【轉】NumPy 教程（超長）

順其自然發表於2021-01-05

NumPy - 簡介

NumPy 是一個 Python 包。它代表 “Numeric Python”。它是一個由多維陣列物件和用於處理陣列的例程集合組成的庫。

Numeric，即 NumPy 的前身，是由 Jim Hugunin 開發的。也開發了另一個包 Numarray ，它擁有一些額外的功能。 2005年，Travis Oliphant 通過將 Numarray 的功能整合到 Numeric 包中來建立 NumPy 包。這個開源專案有很多貢獻者。

NumPy 操作

使用NumPy，開發人員可以執行以下操作：

陣列的算數和邏輯運算。
傅立葉變換和用於圖形操作的例程。
與線性代數有關的操作。 NumPy 擁有線性代數和隨機數生成的內建函式。

NumPy – MatLab 的替代之一

NumPy 通常與 SciPy（Scientific Python）和 Matplotlib（繪相簿）一起使用。這種組合廣泛用於替代 MatLab，是一個流行的技術計算平臺。但是，Python 作為 MatLab 的替代方案，現在被視為一種更加現代和完整的程式語言。

NumPy 是開源的，這是它的一個額外的優勢。

NumPy - 環境

線上嘗試

我們已經線上設定了 NumPy 程式設計環境，以便線上編譯和執行所有可用的示例。它向你提供了信心，並使您能夠使用不同的選項驗證程式，隨意修改任何示例並線上執行。

使用我們的線上編譯器嘗試一下示例，它位於 CodingGround
import numpy as np 
a =  'hello world'  
print a
對於本教程中給出的大多數示例，你會在我們的網站程式碼部分的右上角找到一個Try it選項，這會把你帶到線上編譯器。所以快來使用它，享受你的學習吧。

標準的 Python 發行版不會與 NumPy 模組捆綁在一起。一個輕量級的替代方法是使用流行的 Python 包安裝程式 pip 來安裝 NumPy。

pip install numpy

啟用 NumPy 的最佳方法是使用特定於您的作業系統的可安裝的二進位制包。這些二進位制包含完整的 SciPy 技術棧（包括 NumPy，SciPy，matplotlib，IPython，SymPy 以及 Python 核心自帶的其它包）。

Windows

Anaconda (from www.continuum.io) 是一個帶有 SciPy 技術棧的免費 Python 發行版。它也可用於 Linux 和 Mac.

Canopy (www.enthought.com/products/canopy/) 是可用的免費和商業發行版，帶有完整的 SciPy 技術棧，可用於 Windows, Linux and Mac。

Python (x,y): 是個免費的 Python 發行版，帶有 SciPy 技術棧和 Spyder IDE，可用於 Windows。 (從這裡下載：www.python-xy.github.io/)

Linux

Linux 發行版的相應軟體包管理器可用於安裝一個或多個 SciPy 技術棧中的軟體包。

對於 Ubuntu

sudo apt-get install python-numpy 
python-scipy python-matplotlibipythonipythonnotebook python-pandas 
python-sympy python-nose

對於 Fedora

sudo yum install numpyscipy python-matplotlibipython 
python-pandas sympy python-nose atlas-devel

從原始碼構建

核心 Python（2.6.x，2.7.x 和 3.2.x 起）必須安裝distutils，zlib模組應該啟用。

GNU gcc（4.2及以上）C 編譯器必須可用。

要安裝 NumPy，請執行以下命令。

Python setup.py install

要測試 NumPy 模組是否正確安裝，請嘗試從 Python 提示符匯入它。

如果未安裝，將顯示以下錯誤訊息。

Traceback (most recent call last): 
   File "<pyshell#0>", line 1, in <module> 
      import numpy 
ImportError: No module named 'numpy'

或者，使用以下語法匯入NumPy包。

NumPy - Ndarray 物件

NumPy 中定義的最重要的物件是稱為 ndarray 的 N 維陣列型別。它描述相同型別的元素集合。可以使用基於零的索引訪問集合中的專案。

ndarray中的每個元素在記憶體中使用相同大小的塊。 ndarray中的每個元素是資料型別物件的物件（稱為 dtype）。

從ndarray物件提取的任何元素（通過切片）由一個陣列標量型別的 Python 物件表示。下圖顯示了ndarray，資料型別物件（dtype）和陣列標量型別之間的關係。

Ndarray

ndarray類的例項可以通過本教程後面描述的不同的陣列建立例程來構造。基本的ndarray是使用 NumPy 中的陣列函式建立的，如下所示：

numpy.array

它從任何暴露陣列介面的物件，或從返回陣列的任何方法建立一個ndarray。

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

上面的構造器接受以下引數：

序號	引數及描述
1.	`object` 任何暴露陣列介面方法的物件都會返回一個陣列或任何（巢狀）序列。
2.	`dtype` 陣列的所需資料型別，可選。
3.	`copy` 可選，預設為`true`，物件是否被複制。
4.	`order` `C`（按行）、`F`（按列）或`A`（任意，預設）。
5.	`subok` 預設情況下，返回的陣列被強制為基類陣列。如果為`true`，則返回子類。
6.	`ndimin` 指定返回陣列的最小維數。

看看下面的例子來更好地理解。

示例 1

import numpy as np 
a = np.array([1,2,3])  
print a

輸出如下：

[1, 2, 3]

示例 2

# 多於一個維度  
import numpy as np 
a = np.array([[1,  2],  [3,  4]])  
print a

輸出如下：

[[1, 2] 
 [3, 4]]

示例 3

# 最小維度  
import numpy as np 
a = np.array([1,  2,  3,4,5], ndmin =  2)  
print a

輸出如下：

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

示例 4

# dtype 引數  
import numpy as np 
a = np.array([1,  2,  3], dtype = complex)  
print a

輸出如下：

[ 1.+0.j,  2.+0.j,  3.+0.j]

**ndarray ** 物件由計算機記憶體中的一維連續區域組成，帶有將每個元素對映到記憶體塊中某個位置的索引方案。記憶體塊以按行（C 風格）或按列（FORTRAN 或 MatLab 風格）的方式儲存元素。

NumPy - 資料型別

NumPy 支援比 Python 更多種類的數值型別。下表顯示了 NumPy 中定義的不同標量資料型別。

序號	資料型別及描述
1.	`bool_` 儲存為一個位元組的布林值（真或假）
2.	`int_` 預設整數，相當於 C 的`long`，通常為`int32`或`int64`
3.	`intc` 相當於 C 的`int`，通常為`int32`或`int64`
4.	`intp` 用於索引的整數，相當於 C 的`size_t`，通常為`int32`或`int64`
5.	`int8` 位元組（-128 ~ 127）
6.	`int16` 16 位整數（-32768 ~ 32767）
7.	`int32` 32 位整數（-2147483648 ~ 2147483647）
8.	`int64` 64 位整數（-9223372036854775808 ~ 9223372036854775807）
9.	`uint8` 8 位無符號整數（0 ~ 255）
10.	`uint16` 16 位無符號整數（0 ~ 65535）
11.	`uint32` 32 位無符號整數（0 ~ 4294967295）
12.	`uint64` 64 位無符號整數（0 ~ 18446744073709551615）
13.	`float_` `float64`的簡寫
14.	`float16` 半精度浮點：符號位，5 位指數，10 位尾數
15.	`float32` 單精度浮點：符號位，8 位指數，23 位尾數
16.	`float64` 雙精度浮點：符號位，11 位指數，52 位尾數
17.	`complex_` `complex128`的簡寫
18.	`complex64` 複數，由兩個 32 位浮點表示（實部和虛部）
19.	`complex128` 複數，由兩個 64 位浮點表示（實部和虛部）

NumPy 數字型別是dtype（資料型別）物件的例項，每個物件具有唯一的特徵。這些型別可以是np.bool_，np.float32等。

資料型別物件 (`dtype`)

資料型別物件描述了對應於陣列的固定記憶體塊的解釋，取決於以下方面：

資料型別（整數、浮點或者 Python 物件）
資料大小
位元組序（小端或大端）
在結構化型別的情況下，欄位的名稱，每個欄位的資料型別，和每個欄位佔用的記憶體塊部分。
如果資料型別是子序列，它的形狀和資料型別。

位元組順序取決於資料型別的字首<或>。 <意味著編碼是小端（最小有效位元組儲存在最小地址中）。 >意味著編碼是大端（最大有效位元組儲存在最小地址中）。

dtype可由一下語法構造：

numpy.dtype(object, align, copy)

引數為：

Object：被轉換為資料型別的物件。
Align：如果為true，則向欄位新增間隔，使其類似 C 的結構體。
Copy ? 生成dtype物件的新副本，如果為flase，結果是內建資料型別物件的引用。

示例 1

# 使用陣列標量型別  
import numpy as np 
dt = np.dtype(np.int32)  
print dt

輸出如下：

int32

示例 2

#int8，int16，int32，int64 可替換為等價的字串 'i1'，'i2'，'i4'，以及其他。  
import numpy as np 

dt = np.dtype('i4')  
print dt

輸出如下：

int32

示例 3

# 使用端記號  
import numpy as np 
dt = np.dtype('>i4')  
print dt

輸出如下：

>i4

下面的例子展示了結構化資料型別的使用。這裡宣告瞭欄位名稱和相應的標量資料型別。

示例 4

# 首先建立結構化資料型別。  
import numpy as np 
dt = np.dtype([('age',np.int8)])  
print dt

輸出如下：

[('age', 'i1')]

示例 5

# 現在將其應用於 ndarray 物件  
import numpy as np 

dt = np.dtype([('age',np.int8)]) 
a = np.array([(10,),(20,),(30,)], dtype = dt)  
print a

輸出如下：

[(10,) (20,) (30,)]

示例 6

# 檔名稱可用於訪問 age 列的內容  
import numpy as np 

dt = np.dtype([('age',np.int8)]) 
a = np.array([(10,),(20,),(30,)], dtype = dt)  
print a['age']

輸出如下：

[10 20 30]

示例 7

以下示例定義名為 student 的結構化資料型別，其中包含字串欄位name，整數字段age和浮點欄位marks。此dtype應用於ndarray物件。

import numpy as np 
student = np.dtype([('name','S20'),  ('age',  'i1'),  ('marks',  'f4')])  
print student

輸出如下：

[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])

示例 8

import numpy as np 

student = np.dtype([('name','S20'),  ('age',  'i1'),  ('marks',  'f4')]) 
a = np.array([('abc',  21,  50),('xyz',  18,  75)], dtype = student)  
print a

輸出如下：

[('abc', 21, 50.0), ('xyz', 18, 75.0)]

每個內建型別都有一個唯一定義它的字元程式碼：

'b'：布林值
'i'：符號整數
'u'：無符號整數
'f'：浮點
'c'：複數浮點
'm'：時間間隔
'M'：日期時間
'O'：Python 物件
'S', 'a'：位元組串
'U'：Unicode
'V'：原始資料（void）

NumPy - 陣列屬性

這一章中，我們會討論 NumPy 的多種陣列屬性。

`ndarray.shape`

這一陣列屬性返回一個包含陣列維度的元組，它也可以用於調整陣列大小。

示例 1

import numpy as np 
a = np.array([[1,2,3],[4,5,6]])  
print a.shape

輸出如下：

(2, 3)

示例 2

# 這會調整陣列大小  
import numpy as np 

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

輸出如下：

[[1, 2] 
 [3, 4] 
 [5, 6]]

示例 3

NumPy 也提供了reshape函式來調整陣列大小。

import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) 
b = a.reshape(3,2)  
print b

輸出如下：

[[1, 2] 
 [3, 4] 
 [5, 6]]

`ndarray.ndim`

這一陣列屬性返回陣列的維數。

示例 1

# 等間隔數字的陣列  
import numpy as np 
a = np.arange(24)  print a

輸出如下：

[0 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16 17 18 19 20 21 22 23]

示例 2

# 一維陣列  
import numpy as np 
a = np.arange(24) a.ndim 
# 現在調整其大小
b = a.reshape(2,4,3)  
print b 
# b 現在擁有三個維度

輸出如下：

[[[ 0,  1,  2] 
  [ 3,  4,  5] 
  [ 6,  7,  8] 
  [ 9, 10, 11]]  
  [[12, 13, 14] 
   [15, 16, 17]
   [18, 19, 20] 
   [21, 22, 23]]]

`numpy.itemsize`

這一陣列屬性返回陣列中每個元素的位元組單位長度。

示例 1

# 陣列的 dtype 為 int8（一個位元組）  
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.int8)  
print x.itemsize

輸出如下：

示例 2

# 陣列的 dtype 現在為 float32（四個位元組）  
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.float32)  
print x.itemsize

輸出如下：

`numpy.flags`

ndarray物件擁有以下屬性。這個函式返回了它們的當前值。

序號	屬性及描述
1.	`C_CONTIGUOUS (C)` 陣列位於單一的、C 風格的連續區段內
2.	`F_CONTIGUOUS (F)` 陣列位於單一的、Fortran 風格的連續區段內
3.	`OWNDATA (O)` 陣列的記憶體從其它物件處借用
4.	`WRITEABLE (W)` 資料區域可寫入。將它設定為`flase`會鎖定資料，使其只讀
5.	`ALIGNED (A)` 資料和任何元素會為硬體適當對齊
6.	`UPDATEIFCOPY (U)` 這個陣列是另一陣列的副本。當這個陣列釋放時，源陣列會由這個陣列中的元素更新

示例

下面的例子展示當前的標誌。

import numpy as np 
x = np.array([1,2,3,4,5])  
print x.flags

輸出如下：

C_CONTIGUOUS : True 
F_CONTIGUOUS : True 
OWNDATA : True 
WRITEABLE : True 
ALIGNED : True 
UPDATEIFCOPY : False

NumPy - 陣列建立例程

新的ndarray物件可以通過任何下列陣列建立例程或使用低階ndarray建構函式構造。

`numpy.empty`

它建立指定形狀和dtype的未初始化陣列。它使用以下建構函式：

numpy.empty(shape, dtype = float, order = 'C')

構造器接受下列引數：

序號	引數及描述
1.	`Shape` 空陣列的形狀，整數或整數元組
2.	`Dtype` 所需的輸出陣列型別，可選
3.	`Order` `'C'`為按行的 C 風格陣列，`'F'`為按列的 Fortran 風格陣列

示例

下面的程式碼展示空陣列的例子：

import numpy as np 
x = np.empty([3,2], dtype =  int)  
print x

輸出如下：

[[22649312    1701344351] 
 [1818321759  1885959276] 
 [16779776    156368896]]

注意：陣列元素為隨機值，因為它們未初始化。

`numpy.zeros`

返回特定大小，以 0 填充的新陣列。

numpy.zeros(shape, dtype = float, order = 'C')

構造器接受下列引數：

序號	引數及描述
1.	`Shape` 空陣列的形狀，整數或整數元組
2.	`Dtype` 所需的輸出陣列型別，可選
3.	`Order` `'C'`為按行的 C 風格陣列，`'F'`為按列的 Fortran 風格陣列

示例 1

# 含有 5 個 0 的陣列，預設型別為 float  
import numpy as np 
x = np.zeros(5)  
print x

輸出如下：

[ 0.  0.  0.  0.  0.]

示例 2

import numpy as np 
x = np.zeros((5,), dtype = np.int)  
print x

輸出如下：

[0  0  0  0  0]

示例 3

# 自定義型別 
import numpy as np 
x = np.zeros((2,2), dtype =  [('x',  'i4'),  ('y',  'i4')])  
print x

輸出如下：

[[(0,0)(0,0)]
 [(0,0)(0,0)]]

`numpy.ones`

返回特定大小，以 1 填充的新陣列。

numpy.ones(shape, dtype = None, order = 'C')

構造器接受下列引數：

序號	引數及描述
1.	`Shape` 空陣列的形狀，整數或整數元組
2.	`Dtype` 所需的輸出陣列型別，可選
3.	`Order` `'C'`為按行的 C 風格陣列，`'F'`為按列的 Fortran 風格陣列

示例 1

# 含有 5 個 1 的陣列，預設型別為 float  
import numpy as np 
x = np.ones(5)  print x

輸出如下：

[ 1.  1.  1.  1.  1.]

示例 2

import numpy as np 
x = np.ones([2,2], dtype =  int)  
print x

輸出如下：

[[1  1] 
 [1  1]]

NumPy - 來自現有資料的陣列

這一章中，我們會討論如何從現有資料建立陣列。

`numpy.asarray`

此函式類似於numpy.array，除了它有較少的引數。這個例程對於將 Python 序列轉換為ndarray非常有用。

numpy.asarray(a, dtype = None, order = None)

構造器接受下列引數：

序號	引數及描述
1.	`a` 任意形式的輸入引數，比如列表、列表的元組、元組、元組的元組、元組的列表
2.	`dtype` 通常，輸入資料的型別會應用到返回的`ndarray`
3.	`order` `'C'`為按行的 C 風格陣列，`'F'`為按列的 Fortran 風格陣列

下面的例子展示瞭如何使用asarray函式：

示例 1

# 將列表轉換為 ndarray 
import numpy as np 

x =  [1,2,3] 
a = np.asarray(x)  
print a

輸出如下：

[1  2  3]

示例 2

# 設定了 dtype  
import numpy as np 

x =  [1,2,3] 
a = np.asarray(x, dtype =  float)  
print a

輸出如下：

[ 1.  2.  3.]

示例 3

# 來自元組的 ndarray  
import numpy as np 

x =  (1,2,3) 
a = np.asarray(x)  
print a

輸出如下：

[1  2  3]

示例 4

# 來自元組列表的 ndarray
import numpy as np 

x =  [(1,2,3),(4,5)] 
a = np.asarray(x)  
print a

輸出如下：

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

`numpy.frombuffer`

此函式將緩衝區解釋為一維陣列。暴露緩衝區介面的任何物件都用作引數來返回ndarray。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

構造器接受下列引數：

序號	引數及描述
1.	`buffer` 任何暴露緩衝區藉口的物件
2.	`dtype` 返回陣列的資料型別，預設為`float`
3.	`count` 需要讀取的資料數量，預設為`-1`，讀取所有資料
4.	`offset` 需要讀取的起始位置，預設為`0`

示例

下面的例子展示了frombuffer函式的用法。

import numpy as np 
s =  'Hello World' 
a = np.frombuffer(s, dtype =  'S1')  
print a

輸出如下：

['H'  'e'  'l'  'l'  'o'  ' '  'W'  'o'  'r'  'l'  'd']

`numpy.fromiter`

此函式從任何可迭代物件構建一個ndarray物件，返回一個新的一維陣列。

numpy.fromiter(iterable, dtype, count = -1)

構造器接受下列引數：

序號	引數及描述
1.	`iterable` 任何可迭代物件
2.	`dtype` 返回陣列的資料型別
3.	`count` 需要讀取的資料數量，預設為`-1`，讀取所有資料

以下示例展示瞭如何使用內建的range()函式返回列表物件。此列表的迭代器用於形成ndarray物件。

示例 1

# 使用 range 函式建立列表物件  
import numpy as np 
list = range(5)  
print list

輸出如下：

[0,  1,  2,  3,  4]

示例 2

# 從列表中獲得迭代器  
import numpy as np 
list = range(5) 
it = iter(list)  
# 使用迭代器建立 ndarray 
x = np.fromiter(it, dtype =  float)  
print x

輸出如下：

[0.   1.   2.   3.   4.]

NumPy - 來自數值範圍的陣列

這一章中，我們會學到如何從數值範圍建立陣列。

`numpy.arange`

這個函式返回ndarray物件，包含給定範圍內的等間隔值。

numpy.arange(start, stop, step, dtype)

構造器接受下列引數：

序號	引數及描述
1.	`start` 範圍的起始值，預設為`0`
2.	`stop` 範圍的終止值（不包含）
3.	`step` 兩個值的間隔，預設為`1`
4.	`dtype` 返回`ndarray`的資料型別，如果沒有提供，則會使用輸入資料的型別。

下面的例子展示瞭如何使用該函式：

示例 1

import numpy as np
x = np.arange(5)  
print x

輸出如下：

[0  1  2  3  4]

示例 2

import numpy as np
# 設定了 dtype
x = np.arange(5, dtype =  float)  
print x

輸出如下：

[0.  1.  2.  3.  4.]

示例 3

# 設定了起始值和終止值引數  
import numpy as np
x = np.arange(10,20,2)  
print x

輸出如下：

[10  12  14  16  18]

`numpy.linspace`

此函式類似於arange()函式。在此函式中，指定了範圍之間的均勻間隔數量，而不是步長。此函式的用法如下。

numpy.linspace(start, stop, num, endpoint, retstep, dtype)

構造器接受下列引數：

序號	引數及描述
1.	`start` 序列的起始值
2.	`stop` 序列的終止值，如果`endpoint`為`true`，該值包含於序列中
3.	`num` 要生成的等間隔樣例數量，預設為`50`
4.	`endpoint` 序列中是否包含`stop`值，預設為`ture`
5.	`retstep` 如果為`true`，返回樣例，以及連續數字之間的步長
6.	`dtype` 輸出`ndarray`的資料型別

下面的例子展示了linspace函式的用法。

示例 1

import numpy as np
x = np.linspace(10,20,5)  
print x

輸出如下：

[10.   12.5   15.   17.5  20.]

示例 2

# 將 endpoint 設為 false
import numpy as np
x = np.linspace(10,20,  5, endpoint =  False)  
print x

輸出如下：

[10.   12.   14.   16.   18.]

示例 3

# 輸出 retstep 值  
import numpy as np

x = np.linspace(1,2,5, retstep =  True)  
print x
# 這裡的 retstep 為 0.25

輸出如下：

(array([ 1.  ,  1.25,  1.5 ,  1.75,  2.  ]), 0.25)

`numpy.logspace`

此函式返回一個ndarray物件，其中包含在對數刻度上均勻分佈的數字。刻度的開始和結束端點是某個底數的冪，通常為 10。

numpy.logscale(start, stop, num, endpoint, base, dtype)

logspace函式的輸出由以下引數決定：

序號	引數及描述
1.	`start` 起始值是`base ** start`
2.	`stop` 終止值是`base ** stop`
3.	`num` 範圍內的數值數量，預設為`50`
4.	`endpoint` 如果為`true`，終止值包含在輸出陣列當中
5.	`base` 對數空間的底數，預設為`10`
6.	`dtype` 輸出陣列的資料型別，如果沒有提供，則取決於其它引數

下面的例子展示了logspace函式的用法。

示例 1

import numpy as np
# 預設底數是 10
a = np.logspace(1.0,  2.0, num =  10)  
print a

輸出如下：

[ 10.           12.91549665     16.68100537      21.5443469  27.82559402      
  35.93813664   46.41588834     59.94842503      77.42636827    100.    ]

示例 2

# 將對數空間的底數設定為 2  
import numpy as np
a = np.logspace(1,10,num =  10,  base  =  2)  
print a

輸出如下：

[ 2.     4.     8.    16.    32.    64.   128.   256.    512.   1024.]

NumPy - 切片和索引

ndarray物件的內容可以通過索引或切片來訪問和修改，就像 Python 的內建容器物件一樣。

如前所述，ndarray物件中的元素遵循基於零的索引。有三種可用的索引方法型別： 欄位訪問，基本切片和高階索引。

基本切片是 Python 中基本切片概念到 n 維的擴充套件。通過將start，stop和step引數提供給內建的slice函式來構造一個 Python slice物件。此slice物件被傳遞給陣列來提取陣列的一部分。

示例 1

import numpy as np
a = np.arange(10)
s = slice(2,7,2)  
print a[s]

輸出如下：

[2  4  6]

在上面的例子中，ndarray物件由arange()函式建立。然後，分別用起始，終止和步長值2，7和2定義切片物件。當這個切片物件傳遞給ndarray時，會對它的一部分進行切片，從索引2到7，步長為2。

通過將由冒號分隔的切片引數（start:stop:step）直接提供給ndarray物件，也可以獲得相同的結果。

示例 2

import numpy as np
a = np.arange(10)
b = a[2:7:2]  
print b

輸出如下：

[2  4  6]

如果只輸入一個引數，則將返回與索引對應的單個專案。如果使用a:，則從該索引向後的所有專案將被提取。如果使用兩個引數（以:分隔），則對兩個索引（不包括停止索引）之間的元素以預設步驟進行切片。

示例 3

# 對單個元素進行切片  
import numpy as np

a = np.arange(10)
b = a[5]  
print b

輸出如下：

示例 4

# 對始於索引的元素進行切片  
import numpy as np
a = np.arange(10)  
print a[2:]

輸出如下：

[2  3  4  5  6  7  8  9]

示例 5

# 對索引之間的元素進行切片  
import numpy as np
a = np.arange(10)  
print a[2:5]

輸出如下：

[2  3  4]

上面的描述也可用於多維ndarray。

示例 6

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print a
# 對始於索引的元素進行切片  
print  '現在我們從索引 a[1:] 開始對陣列切片'  
print a[1:]

輸出如下：

[[1 2 3]
 [3 4 5]
 [4 5 6]]

現在我們從索引 a[1:] 開始對陣列切片
[[3 4 5]
 [4 5 6]]

切片還可以包括省略號（...），來使選擇元組的長度與陣列的維度相同。如果在行位置使用省略號，它將返回包含行中元素的ndarray。

示例 7

# 最開始的陣列  
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print  '我們的陣列是：'  
print a
print  '\n'  
# 這會返回第二列元素的陣列：  
print  '第二列的元素是：'  
print a[...,1]  
print  '\n'  
# 現在我們從第二行切片所有元素：  
print  '第二行的元素是：'  
print a[1,...]  
print  '\n'  
# 現在我們從第二列向後切片所有元素：
print  '第二列及其剩餘元素是：'  
print a[...,1:]

輸出如下：

我們的陣列是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]

第二列的元素是：
[2 4 5]

第二行的元素是：
[3 4 5]

第二列及其剩餘元素是：
[[2 3]
 [4 5]
 [5 6]]

NumPy - 高階索引

如果一個ndarray是非元組序列，資料型別為整數或布林值的ndarray，或者至少一個元素為序列物件的元組，我們就能夠用它來索引ndarray。高階索引始終返回資料的副本。與此相反，切片只提供了一個檢視。

有兩種型別的高階索引：整數和布林值。

整數索引

這種機制有助於基於 N 維索引來獲取陣列中任意元素。每個整數陣列表示該維度的下標值。當索引的元素個數就是目標ndarray的維度時，會變得相當直接。

以下示例獲取了ndarray物件中每一行指定列的一個元素。因此，行索引包含所有行號，列索引指定要選擇的元素。

示例 1

import numpy as np 

x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print y

輸出如下：

[1  4  5]

該結果包括陣列中(0,0)，(1,1)和(2,0)位置處的元素。

下面的示例獲取了 4X3 陣列中的每個角處的元素。行索引是[0,0]和[3,3]，而列索引是[0,2]和[0,2]。

示例 2

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print  '我們的陣列是：'  
print x 
print  '\n' 
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print  '這個陣列的每個角處的元素是：'  
print y

輸出如下：

我們的陣列是：                                                                 
[[ 0  1  2]                                                                   
 [ 3  4  5]                                                                   
 [ 6  7  8]                                                                   
 [ 9 10 11]]

這個陣列的每個角處的元素是：                                      
[[ 0  2]                                                                      
 [ 9 11]]

返回的結果是包含每個角元素的ndarray物件。

高階和基本索引可以通過使用切片:或省略號...與索引陣列組合。以下示例使用slice作為列索引和高階索引。當切片用於兩者時，結果是相同的。但高階索引會導致複製，並且可能有不同的記憶體佈局。

示例 3

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print  '我們的陣列是：'  
print x 
print  '\n'  
# 切片
z = x[1:4,1:3]  
print  '切片之後，我們的陣列變為：'  
print z 
print  '\n'  
# 對列使用高階索引 
y = x[1:4,[1,2]] 
print  '對列使用高階索引來切片：'  
print y

輸出如下：

我們的陣列是：
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8]
 [ 9 10 11]]

切片之後，我們的陣列變為：
[[ 4  5]
 [ 7  8]
 [10 11]]

對列使用高階索引來切片：
[[ 4  5]
 [ 7  8]
 [10 11]]

布林索引

當結果物件是布林運算（例如比較運算子）的結果時，將使用此型別的高階索引。

示例 1

這個例子中，大於 5 的元素會作為布林索引的結果返回。

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print  '我們的陣列是：'  
print x 
print  '\n'  
# 現在我們會列印出大於 5 的元素  
print  '大於 5 的元素是：'  
print x[x >  5]

輸出如下：

我們的陣列是：
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8] 
 [ 9 10 11]] 

大於 5 的元素是：
[ 6  7  8  9 10 11]

示例 2

這個例子使用了~（取補運算子）來過濾NaN。

import numpy as np 
a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print a[~np.isnan(a)]

輸出如下：

[ 1.   2.   3.   4.   5.]

示例 3

以下示例顯示如何從陣列中過濾掉非複數元素。

import numpy as np 
a = np.array([1,  2+6j,  5,  3.5+5j])  
print a[np.iscomplex(a)]

輸出如下：

[2.0+6.j  3.5+5.j]

NumPy - 廣播

術語廣播是指 NumPy 在算術運算期間處理不同形狀的陣列的能力。對陣列的算術運算通常在相應的元素上進行。如果兩個陣列具有完全相同的形狀，則這些操作被無縫執行。

示例 1

import numpy as np 

a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print c

輸出如下：

[10   40   90   160]

如果兩個陣列的維數不相同，則元素到元素的操作是不可能的。然而，在 NumPy 中仍然可以對形狀不相似的陣列進行操作，因為它擁有廣播功能。較小的陣列會廣播到較大陣列的大小，以便使它們的形狀可相容。

如果滿足以下規則，可以進行廣播：

ndim較小的陣列會在前面追加一個長度為 1 的維度。
輸出陣列的每個維度的大小是輸入陣列該維度大小的最大值。
如果輸入在每個維度中的大小與輸出大小匹配，或其值正好為 1，則在計算中可它。
如果輸入的某個維度大小為 1，則該維度中的第一個資料元素將用於該維度的所有計算。

如果上述規則產生有效結果，並且滿足以下條件之一，那麼陣列被稱為可廣播的。

陣列擁有相同形狀。
陣列擁有相同的維數，每個維度擁有相同長度，或者長度為 1。
陣列擁有極少的維度，可以在其前面追加長度為 1 的維度，使上述條件成立。

下面的例稱展示了廣播的示例。

示例 2

import numpy as np 
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 
b = np.array([1.0,2.0,3.0])  
print  '第一個陣列：'  
print a 
print  '\n'  
print  '第二個陣列：'  
print b 
print  '\n'  
print  '第一個陣列加第二個陣列：'  
print a + b

輸出如下：

第一個陣列：
[[ 0. 0. 0.]
 [ 10. 10. 10.]
 [ 20. 20. 20.]
 [ 30. 30. 30.]]

第二個陣列：
[ 1. 2. 3.]

第一個陣列加第二個陣列：
[[ 1. 2. 3.]
 [ 11. 12. 13.]
 [ 21. 22. 23.]
 [ 31. 32. 33.]]

下面的圖片展示了陣列b如何通過廣播來與陣列a相容。

array

NumPy - 陣列上的迭代

NumPy 包包含一個迭代器物件numpy.nditer。它是一個有效的多維迭代器物件，可以用於在陣列上進行迭代。陣列的每個元素可使用 Python 的標準Iterator介面來訪問。

讓我們使用arange()函式建立一個 3X4 陣列，並使用nditer對它進行迭代。

示例 1

import numpy as np
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始陣列是：'  
print a print  '\n'  
print  '修改後的陣列是：'  
for x in np.nditer(a):  
    print x,

輸出如下：

原始陣列是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

修改後的陣列是：
0 5 10 15 20 25 30 35 40 45 50 55

示例 2

迭代的順序匹配陣列的內容佈局，而不考慮特定的排序。這可以通過迭代上述陣列的轉置來看到。

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始陣列是：'  
print a 
print  '\n'  
print  '原始陣列的轉置是：' 
b = a.T 
print b 
print  '\n'  
print  '修改後的陣列是：'  
for x in np.nditer(b):  
    print x,

輸出如下：

原始陣列是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

原始陣列的轉置是：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

修改後的陣列是：
0 5 10 15 20 25 30 35 40 45 50 55

迭代順序

如果相同元素使用 F 風格順序儲存，則迭代器選擇以更有效的方式對陣列進行迭代。

示例 1

import numpy as np
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始陣列是：'  
print a print  '\n'  
print  '原始陣列的轉置是：' 
b = a.T 
print b 
print  '\n'  
print  '以 C 風格順序排序：' 
c = b.copy(order='C')  
print c for x in np.nditer(c):  
    print x,  
print  '\n'  
print  '以 F 風格順序排序：' 
c = b.copy(order='F')  
print c 
for x in np.nditer(c):  
    print x,

輸出如下：

原始陣列是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

原始陣列的轉置是：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

以 C 風格順序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55

以 F 風格順序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55

示例 2

可以通過顯式提醒，來強制nditer物件使用某種順序：

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始陣列是：'  
print a 
print  '\n'  
print  '以 C 風格順序排序：'  
for x in np.nditer(a, order =  'C'):  
    print x,  
print  '\n'  
print  '以 F 風格順序排序：'  
for x in np.nditer(a, order =  'F'):  
    print x,

輸出如下：

原始陣列是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

以 C 風格順序排序：
0 5 10 15 20 25 30 35 40 45 50 55

以 F 風格順序排序：
0 20 40 5 25 45 10 30 50 15 35 55

修改陣列的值

nditer物件有另一個可選引數op_flags。其預設值為只讀，但可以設定為讀寫或只寫模式。這將允許使用此迭代器修改陣列元素。

示例

import numpy as np
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始陣列是：'  
print a 
print  '\n'  
for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x 
print  '修改後的陣列是：'  
print a

輸出如下：

原始陣列是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

修改後的陣列是：
[[ 0 10 20 30]
 [ 40 50 60 70]
 [ 80 90 100 110]]

外部迴圈

nditer類的構造器擁有flags引數，它可以接受下列值：

序號	引數及描述
1.	`c_index` 可以跟蹤 C 順序的索引
2.	`f_index` 可以跟蹤 Fortran 順序的索引
3.	`multi-index` 每次迭代可以跟蹤一種索引型別
4.	`external_loop` 給出的值是具有多個值的一維陣列，而不是零維陣列

示例

在下面的示例中，迭代器遍歷對應於每列的一維陣列。

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始陣列是：'  
print a 
print  '\n'  
print  '修改後的陣列是：'  
for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):  
    print x,

輸出如下：

原始陣列是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

修改後的陣列是：
[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]

廣播迭代

如果兩個陣列是可廣播的，nditer組合物件能夠同時迭代它們。假設陣列a具有維度 3X4，並且存在維度為 1X4 的另一個陣列b，則使用以下型別的迭代器（陣列b被廣播到a的大小）。

示例

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '第一個陣列：'  
print a 
print  '\n'  
print  '第二個陣列：' 
b = np.array([1,  2,  3,  4], dtype =  int)  
print b 
print  '\n'  
print  '修改後的陣列是：'  
for x,y in np.nditer([a,b]):  
    print  "%d:%d"  %  (x,y),

輸出如下：

第一個陣列：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

第二個陣列：
[1 2 3 4]

修改後的陣列是：
0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4

NumPy - 陣列操作

NumPy包中有幾個例程用於處理ndarray物件中的元素。它們可以分為以下型別：

修改形狀

序號	形狀及描述
1.	`reshape` 不改變資料的條件下修改形狀
2.	`flat` 陣列上的一維迭代器
3.	`flatten` 返回摺疊為一維的陣列副本
4.	`ravel` 返回連續的展開陣列

`numpy.reshape`

這個函式在不改變資料的條件下修改形狀，它接受如下引數：

numpy.reshape(arr, newshape, order')

其中：

arr：要修改形狀的陣列
newshape：整數或者整數陣列，新的形狀應當相容原有形狀
order：'C'為 C 風格順序，'F'為 F 風格順序，'A'為保留原順序。

例子

import numpy as np
a = np.arange(8)
print '原始陣列：'
print a
print '\n'

b = a.reshape(4,2)
print '修改後的陣列：'
print b

輸出如下：

原始陣列：
[0 1 2 3 4 5 6 7]

修改後的陣列：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

`numpy.ndarray.flat`

該函式返回陣列上的一維迭代器，行為類似 Python 內建的迭代器。

例子

import numpy as np 
a = np.arange(8).reshape(2,4) 
print '原始陣列：' 
print a 
print '\n' 

print '呼叫 flat 函式之後：' 
# 返回展開陣列中的下標的對應元素 
print a.flat[5]

輸出如下：

原始陣列：
[[0 1 2 3]
 [4 5 6 7]]

呼叫 flat 函式之後：
5

`numpy.ndarray.flatten`

該函式返回摺疊為一維的陣列副本，函式接受下列引數：

ndarray.flatten(order)

其中：

order：'C' -- 按行，'F' -- 按列，'A' -- 原順序，'k' -- 元素在記憶體中的出現順序。

例子

import numpy as np 
a = np.arange(8).reshape(2,4) 

print '原陣列：' 
print a 
print '\n'  
# default is column-major 

print '展開的陣列：' 
print a.flatten() 
print '\n'  

print '以 F 風格順序展開的陣列：' 
print a.flatten(order = 'F')

輸出如下：

原陣列：
[[0 1 2 3]
 [4 5 6 7]]

展開的陣列：
[0 1 2 3 4 5 6 7]

以 F 風格順序展開的陣列：
[0 4 1 5 2 6 3 7]

`numpy.ravel`

這個函式返回展開的一維陣列，並且按需生成副本。返回的陣列和輸入陣列擁有相同資料型別。這個函式接受兩個引數。

numpy.ravel(a, order)

構造器接受下列引數：

order：'C' -- 按行，'F' -- 按列，'A' -- 原順序，'k' -- 元素在記憶體中的出現順序。

例子

import numpy as np 
a = np.arange(8).reshape(2,4) 

print '原陣列：' 
print a 
print '\n'  

print '呼叫 ravel 函式之後：' 
print a.ravel()  
print '\n' 

print '以 F 風格順序呼叫 ravel 函式之後：' 
print a.ravel(order = 'F')

原陣列：
[[0 1 2 3]
 [4 5 6 7]]

呼叫 ravel 函式之後：
[0 1 2 3 4 5 6 7]

以 F 風格順序呼叫 ravel 函式之後：
[0 4 1 5 2 6 3 7]

翻轉操作

序號	操作及描述
1.	`transpose` 翻轉陣列的維度
2.	`ndarray.T` 和`self.transpose()`相同
3.	`rollaxis` 向後滾動指定的軸
4.	`swapaxes` 互換陣列的兩個軸

`numpy.transpose`

這個函式翻轉給定陣列的維度。如果可能的話它會返回一個檢視。函式接受下列引數：

numpy.transpose(arr, axes)

其中：

arr：要轉置的陣列
axes：整數的列表，對應維度，通常所有維度都會翻轉。

例子

import numpy as np 
a = np.arange(12).reshape(3,4) 

print '原陣列：' 
print a  
print '\n' 

print '轉置陣列：' 
print np.transpose(a)

輸出如下：

原陣列：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

轉置陣列：
[[ 0 4 8]
 [ 1 5 9]
 [ 2 6 10]
 [ 3 7 11]]

`numpy.ndarray.T`

該函式屬於ndarray類，行為類似於numpy.transpose。

例子

import numpy as np 
a = np.arange(12).reshape(3,4) 

print '原陣列：' 
print a 
print '\n'  

print '轉置陣列：' 
print a.T

輸出如下：

原陣列：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

轉置陣列：
[[ 0 4 8]
 [ 1 5 9]
 [ 2 6 10]
 [ 3 7 11]]

`numpy.rollaxis`

該函式向後滾動特定的軸，直到一個特定位置。這個函式接受三個引數：

numpy.rollaxis(arr, axis, start)

其中：

arr：輸入陣列
axis：要向後滾動的軸，其它軸的相對位置不會改變
start：預設為零，表示完整的滾動。會滾動到特定位置。

例子

# 建立了三維的 ndarray 
import numpy as np 
a = np.arange(8).reshape(2,2,2) 

print '原陣列：' 
print a 
print '\n'
# 將軸 2 滾動到軸 0（寬度到深度）

print '呼叫 rollaxis 函式：' 
print np.rollaxis(a,2)  
# 將軸 0 滾動到軸 1：（寬度到高度）
print '\n' 

print '呼叫 rollaxis 函式：' 
print np.rollaxis(a,2,1)

輸出如下：

原陣列：
[[[0 1]
 [2 3]]
 [[4 5]
 [6 7]]]

呼叫 rollaxis 函式：
[[[0 2]
 [4 6]]
 [[1 3]
 [5 7]]]

呼叫 rollaxis 函式：
[[[0 2]
 [1 3]]
 [[4 6]
 [5 7]]]

`numpy.swapaxes`

該函式交換陣列的兩個軸。對於 1.10 之前的 NumPy 版本，會返回交換後陣列的試圖。這個函式接受下列引數：

numpy.swapaxes(arr, axis1, axis2)

arr：要交換其軸的輸入陣列
axis1：對應第一個軸的整數
axis2：對應第二個軸的整數

# 建立了三維的 ndarray 
import numpy as np 
a = np.arange(8).reshape(2,2,2) 

print '原陣列：'
print a 
print '\n'  
# 現在交換軸 0（深度方向）到軸 2（寬度方向）

print '呼叫 swapaxes 函式後的陣列：' 
print np.swapaxes(a, 2, 0)

輸出如下：

原陣列：
[[[0 1]
 [2 3]]

 [[4 5]
  [6 7]]]

呼叫 swapaxes 函式後的陣列：
[[[0 4]
 [2 6]]
 
 [[1 5]
  [3 7]]]

修改維度

序號	維度和描述
1.	`broadcast` 產生模仿廣播的物件
2.	`broadcast_to` 將陣列廣播到新形狀
3.	`expand_dims` 擴充套件陣列的形狀
4.	`squeeze` 從陣列的形狀中刪除單維條目

`broadcast`

如前所述，NumPy 已經內建了對廣播的支援。此功能模仿廣播機制。它返回一個物件，該物件封裝了將一個陣列廣播到另一個陣列的結果。

該函式使用兩個陣列作為輸入引數。下面的例子說明了它的用法。

import numpy as np 
x = np.array([[1], [2], [3]]) 
y = np.array([4, 5, 6])  
   
# 對 y 廣播 x
b = np.broadcast(x,y)  
# 它擁有 iterator 屬性，基於自身元件的迭代器元組 

print '對 y 廣播 x：' 
r,c = b.iters 
print r.next(), c.next() 
print r.next(), c.next() 
print '\n'  
# shape 屬性返回廣播物件的形狀

print '廣播物件的形狀：' 
print b.shape 
print '\n'  
# 手動使用 broadcast 將 x 與 y 相加
b = np.broadcast(x,y) 
c = np.empty(b.shape) 

print '手動使用 broadcast 將 x 與 y 相加：' 
print c.shape 
print '\n'  
c.flat = [u + v for (u,v) in b] 

print '呼叫 flat 函式：' 
print c 
print '\n'  
# 獲得了和 NumPy 內建的廣播支援相同的結果

print 'x 與 y 的和：' 
print x + y

輸出如下：

對 y 廣播 x：
1 4
1 5

廣播物件的形狀：
(3, 3)

手動使用 broadcast 將 x 與 y 相加：
(3, 3)

呼叫 flat 函式：
[[ 5. 6. 7.]
 [ 6. 7. 8.]
 [ 7. 8. 9.]]

x 與 y 的和：
[[5 6 7]
 [6 7 8]
 [7 8 9]]

`numpy.broadcast_to`

此函式將陣列廣播到新形狀。它在原始陣列上返回只讀檢視。它通常不連續。如果新形狀不符合 NumPy 的廣播規則，該函式可能會丟擲ValueError。

注意 - 此功能可用於 1.10.0 及以後的版本。

該函式接受以下引數。

numpy.broadcast_to(array, shape, subok)

例子

import numpy as np 
a = np.arange(4).reshape(1,4) 

print '原陣列：' 
print a 
print '\n'  

print '呼叫 broadcast_to 函式之後：' 
print np.broadcast_to(a,(4,4))

輸出如下：

[[0  1  2  3] 
 [0  1  2  3] 
 [0  1  2  3] 
 [0  1  2  3]]

`numpy.expand_dims`

函式通過在指定位置插入新的軸來擴充套件陣列形狀。該函式需要兩個引數：

numpy.expand_dims(arr, axis)

其中：

arr：輸入陣列
axis：新軸插入的位置

例子

import numpy as np 
x = np.array(([1,2],[3,4])) 

print '陣列 x：' 
print x 
print '\n'  
y = np.expand_dims(x, axis = 0) 

print '陣列 y：' 
print y 
print '\n'

print '陣列 x 和 y 的形狀：' 
print x.shape, y.shape 
print '\n'  
# 在位置 1 插入軸
y = np.expand_dims(x, axis = 1) 

print '在位置 1 插入軸之後的陣列 y：' 
print y 
print '\n'  

print 'x.ndim 和 y.ndim：' 
print x.ndim,y.ndim 
print '\n'  

print 'x.shape 和 y.shape：' 
print x.shape, y.shape

輸出如下：

陣列 x：
[[1 2]
 [3 4]]

陣列 y：
[[[1 2]
 [3 4]]]

陣列 x 和 y 的形狀：
(2, 2) (1, 2, 2)

在位置 1 插入軸之後的陣列 y：
[[[1 2]]
 [[3 4]]]

x.shape 和 y.shape：
2 3

x.shape and y.shape:
(2, 2) (2, 1, 2)

`numpy.squeeze`

函式從給定陣列的形狀中刪除一維條目。此函式需要兩個引數。

numpy.squeeze(arr, axis)

其中：

arr：輸入陣列
axis：整數或整數元組，用於選擇形狀中單一維度條目的子集

例子

import numpy as np  
x = np.arange(9).reshape(1,3,3) 

print '陣列 x：' 
print x 
print '\n'  
y = np.squeeze(x) 

print '陣列 y：' 
print y 
print '\n'  

print '陣列 x 和 y 的形狀：' 
print x.shape, y.shape

輸出如下：

陣列 x：
[[[0 1 2]
 [3 4 5]
 [6 7 8]]]

陣列 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]

陣列 x 和 y 的形狀：
(1, 3, 3) (3, 3)

陣列的連線

序號	陣列及描述
1.	`concatenate` 沿著現存的軸連線資料序列
2.	`stack` 沿著新軸連線陣列序列
3.	`hstack` 水平堆疊序列中的陣列（列方向）
4.	`vstack` 豎直堆疊序列中的陣列（行方向）

`numpy.concatenate`

陣列的連線是指連線。此函式用於沿指定軸連線相同形狀的兩個或多個陣列。該函式接受以下引數。

numpy.concatenate((a1, a2, ...), axis)

其中：

a1, a2, ...：相同型別的陣列序列
axis：沿著它連線陣列的軸，預設為 0

例子

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

print '第一個陣列：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 

print '第二個陣列：' 
print b 
print '\n'  
# 兩個陣列的維度相同 

print '沿軸 0 連線兩個陣列：' 
print np.concatenate((a,b)) 
print '\n'  

print '沿軸 1 連線兩個陣列：' 
print np.concatenate((a,b),axis = 1)

輸出如下：

第一個陣列：
[[1 2]
 [3 4]]

第二個陣列：
[[5 6]
 [7 8]]

沿軸 0 連線兩個陣列：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

沿軸 1 連線兩個陣列：
[[1 2 5 6]
 [3 4 7 8]]

`numpy.stack`

此函式沿新軸連線陣列序列。此功能新增自 NumPy 版本 1.10.0。需要提供以下引數。

numpy.stack(arrays, axis)

其中：

arrays：相同形狀的陣列序列
axis：返回陣列中的軸，輸入陣列沿著它來堆疊

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

print '第一個陣列：' 
print a 
print '\n'
b = np.array([[5,6],[7,8]]) 

print '第二個陣列：' 
print b 
print '\n'  

print '沿軸 0 堆疊兩個陣列：' 
print np.stack((a,b),0) 
print '\n'  

print '沿軸 1 堆疊兩個陣列：' 
print np.stack((a,b),1)

輸出如下：

第一個陣列：
[[1 2]
 [3 4]]

第二個陣列：
[[5 6]
 [7 8]]

沿軸 0 堆疊兩個陣列：
[[[1 2]
 [3 4]]
 [[5 6]
 [7 8]]]

沿軸 1 堆疊兩個陣列：
[[[1 2]
 [5 6]]
 [[3 4]
 [7 8]]]

`numpy.hstack`

numpy.stack函式的變體，通過堆疊來生成水平的單個陣列。

例子

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

print '第一個陣列：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 

print '第二個陣列：' 
print b 
print '\n'  

print '水平堆疊：' 
c = np.hstack((a,b)) 
print c 
print '\n'

輸出如下：

第一個陣列：
[[1 2]
 [3 4]]

第二個陣列：
[[5 6]
 [7 8]]

水平堆疊：
[[1 2 5 6]
 [3 4 7 8]]

`numpy.vstack`

numpy.stack函式的變體，通過堆疊來生成豎直的單個陣列。

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

print '第一個陣列：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 

print '第二個陣列：' 
print b 
print '\n'

print '豎直堆疊：' 
c = np.vstack((a,b)) 
print c

輸出如下：

第一個陣列：
[[1 2]
 [3 4]]

第二個陣列：
[[5 6]
 [7 8]]

豎直堆疊：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

陣列分割

序號	陣列及操作
1.	`split` 將一個陣列分割為多個子陣列
2.	`hsplit` 將一個陣列水平分割為多個子陣列（按列）
3.	`vsplit` 將一個陣列豎直分割為多個子陣列（按行）

`numpy.split`

該函式沿特定的軸將陣列分割為子陣列。函式接受三個引數：

numpy.split(ary, indices_or_sections, axis)

其中：

ary：被分割的輸入陣列
indices_or_sections：可以是整數，表明要從輸入陣列建立的，等大小的子陣列的數量。如果此引數是一維陣列，則其元素表明要建立新子陣列的點。
axis：預設為 0

例子

import numpy as np 
a = np.arange(9) 

print '第一個陣列：' 
print a 
print '\n'  

print '將陣列分為三個大小相等的子陣列：' 
b = np.split(a,3) 
print b 
print '\n'  

print '將陣列在一維陣列中表明的位置分割：' 
b = np.split(a,[4,7])
print b

輸出如下：

第一個陣列：
[0 1 2 3 4 5 6 7 8]

將陣列分為三個大小相等的子陣列：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]

將陣列在一維陣列中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

`numpy.hsplit`

numpy.hsplit是split()函式的特例，其中軸為 1 表示水平分割，無論輸入陣列的維度是什麼。

import numpy as np 
a = np.arange(16).reshape(4,4) 

print '第一個陣列：' 
print a 
print '\n'  

print '水平分割：' 
b = np.hsplit(a,2) 
print b 
print '\n'

輸出：

第一個陣列：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]
 [12 13 14 15]]

水平分割：                                                         
[array([[ 0,  1],                                                             
       [ 4,  5],                                                              
       [ 8,  9],                                                              
       [12, 13]]), array([[ 2,  3],                                           
       [ 6,  7],                                                              
       [10, 11],                                                              
       [14, 15]])]

`numpy.vsplit`

numpy.vsplit是split()函式的特例，其中軸為 0 表示豎直分割，無論輸入陣列的維度是什麼。下面的例子使之更清楚。

import numpy as np 
a = np.arange(16).reshape(4,4) 

print '第一個陣列：' 
print a 
print '\n'

print '豎直分割：' 
b = np.vsplit(a,2) 
print b

輸出如下：

第一個陣列：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]
 [12 13 14 15]]

豎直分割：                                                           
[array([[0, 1, 2, 3],                                                         
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],                               
       [12, 13, 14, 15]])]

新增/刪除元素

序號	元素及描述
1.	`resize` 返回指定形狀的新陣列
2.	`append` 將值新增到陣列末尾
3.	`insert` 沿指定軸將值插入到指定下標之前
4.	`delete` 返回刪掉某個軸的子陣列的新陣列
5.	`unique` 尋找陣列內的唯一元素

`numpy.resize`

此函式返回指定大小的新陣列。如果新大小大於原始大小，則包含原始陣列中的元素的重複副本。該函式接受以下引數。

numpy.resize(arr, shape)

其中：

arr：要修改大小的輸入陣列
shape：返回陣列的新形狀

例子

import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) 

print '第一個陣列：' 
print a 
print '\n'

print '第一個陣列的形狀：' 
print a.shape 
print '\n'  
b = np.resize(a, (3,2)) 

print '第二個陣列：' 
print b 
print '\n'  

print '第二個陣列的形狀：' 
print b.shape 
print '\n'  
# 要注意 a 的第一行在 b 中重複出現，因為尺寸變大了 

print '修改第二個陣列的大小：' 
b = np.resize(a,(3,3)) 
print b

輸出如下：

第一個陣列：
[[1 2 3]
 [4 5 6]]

第一個陣列的形狀：
(2, 3)

第二個陣列：
[[1 2]
 [3 4]
 [5 6]]

第二個陣列的形狀：
(3, 2)

修改第二個陣列的大小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]

`numpy.append`

此函式在輸入陣列的末尾新增值。附加操作不是原地的，而是分配新的陣列。此外，輸入陣列的維度必須匹配否則將生成ValueError。

函式接受下列函式：

numpy.append(arr, values, axis)

其中：

arr：輸入陣列
values：要向arr新增的值，比如和arr形狀相同（除了要新增的軸）
axis：沿著它完成操作的軸。如果沒有提供，兩個引數都會被展開。

例子

import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) 

print '第一個陣列：' 
print a 
print '\n'  

print '向陣列新增元素：' 
print np.append(a, [7,8,9]) 
print '\n'  

print '沿軸 0 新增元素：' 
print np.append(a, [[7,8,9]],axis = 0) 
print '\n'  

print '沿軸 1 新增元素：' 
print np.append(a, [[5,5,5],[7,8,9]],axis = 1)

輸出如下：

第一個陣列：
[[1 2 3]
 [4 5 6]]

向陣列新增元素：
[1 2 3 4 5 6 7 8 9]

沿軸 0 新增元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]

沿軸 1 新增元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

`numpy.insert`

此函式在給定索引之前，沿給定軸在輸入陣列中插入值。如果值的型別轉換為要插入，則它與輸入陣列不同。插入沒有原地的，函式會返回一個新陣列。此外，如果未提供軸，則輸入陣列會被展開。

insert()函式接受以下引數：

numpy.insert(arr, obj, values, axis)

其中：

arr：輸入陣列
obj：在其之前插入值的索引
values：要插入的值
axis：沿著它插入的軸，如果未提供，則輸入陣列會被展開

例子

import numpy as np 
a = np.array([[1,2],[3,4],[5,6]]) 

print '第一個陣列：' 
print a 
print '\n'  

print '未傳遞 Axis 引數。 在插入之前輸入陣列會被展開。' 
print np.insert(a,3,[11,12]) 
print '\n'  
print '傳遞了 Axis 引數。 會廣播值陣列來配輸入陣列。' 

print '沿軸 0 廣播：' 
print np.insert(a,1,[11],axis = 0) 
print '\n'  

print '沿軸 1 廣播：' 
print np.insert(a,1,11,axis = 1)

`numpy.delete`

此函式返回從輸入陣列中刪除指定子陣列的新陣列。與insert()函式的情況一樣，如果未提供軸引數，則輸入陣列將展開。該函式接受以下引數：

Numpy.delete(arr, obj, axis)

其中：

arr：輸入陣列
obj：可以被切片，整數或者整數陣列，表明要從輸入陣列刪除的子陣列
axis：沿著它刪除給定子陣列的軸，如果未提供，則輸入陣列會被展開

例子

import numpy as np 
a = np.arange(12).reshape(3,4) 

print '第一個陣列：' 
print a 
print '\n'  

print '未傳遞 Axis 引數。 在插入之前輸入陣列會被展開。' 
print np.delete(a,5) 
print '\n'  

print '刪除第二列：'  
print np.delete(a,1,axis = 1) 
print '\n'  

print '包含從陣列中刪除的替代值的切片：' 
a = np.array([1,2,3,4,5,6,7,8,9,10]) 
print np.delete(a, np.s_[::2])

輸出如下：

第一個陣列：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

未傳遞 Axis 引數。 在插入之前輸入陣列會被展開。
[ 0 1 2 3 4 6 7 8 9 10 11]

刪除第二列：
[[ 0 2 3]
 [ 4 6 7]
 [ 8 10 11]]

包含從陣列中刪除的替代值的切片：
[ 2 4 6 8 10]

`numpy.unique`

此函式返回輸入陣列中的去重元素陣列。該函式能夠返回一個元組，包含去重陣列和相關索引的陣列。索引的性質取決於函式呼叫中返回引數的型別。

numpy.unique(arr, return_index, return_inverse, return_counts)

其中：

arr：輸入陣列，如果不是一維陣列則會展開
return_index：如果為true，返回輸入陣列中的元素下標
return_inverse：如果為true，返回去重陣列的下標，它可以用於重構輸入陣列
return_counts：如果為true，返回去重陣列中的元素在原陣列中的出現次數

例子

import numpy as np 
a = np.array([5,2,6,2,7,5,6,8,2,9]) 

print '第一個陣列：' 
print a 
print '\n'  

print '第一個陣列的去重值：' 
u = np.unique(a) 
print u 
print '\n'  

print '去重陣列的索引陣列：' 
u,indices = np.unique(a, return_index = True) 
print indices 
print '\n'  

print '我們可以看到每個和原陣列下標對應的數值：' 
print a 
print '\n'  

print '去重陣列的下標：' 
u,indices = np.unique(a,return_inverse = True) 
print u 
print '\n' 

print '下標為：' 
print indices 
print '\n'  

print '使用下標重構原陣列：' 
print u[indices] 
print '\n'  

print '返回去重元素的重複數量：' 
u,indices = np.unique(a,return_counts = True) 
print u 
print indices

輸出如下：

第一個陣列：
[5 2 6 2 7 5 6 8 2 9]

第一個陣列的去重值：
[2 5 6 7 8 9]

去重陣列的索引陣列：
[1 0 2 4 7 9]

我們可以看到每個和原陣列下標對應的數值：
[5 2 6 2 7 5 6 8 2 9]

去重陣列的下標：
[2 5 6 7 8 9]

下標為：
[1 0 2 0 3 1 2 4 0 5]

使用下標重構原陣列：
[5 2 6 2 7 5 6 8 2 9]

返回唯一元素的重複數量：
[2 5 6 7 8 9]
 [3 2 2 1 1 1]

NumPy - 位操作

下面是 NumPy 包中可用的位操作函式。

序號	操作及描述
1.	`bitwise_and` 對陣列元素執行位與操作
2.	`bitwise_or` 對陣列元素執行位或操作
3.	`invert` 計算位非
4.	`left_shift` 向左移動二進位制表示的位
5.	`right_shift` 向右移動二進位制表示的位

`bitwise_and`

通過np.bitwise_and()函式對輸入陣列中的整數的二進位制表示的相應位執行位與運算。

例子

import numpy as np 
print '13 和 17 的二進位制形式：' 
a,b = 13,17 
print bin(a), bin(b) 
print '\n'  

print '13 和 17 的位與：' 
print np.bitwise_and(13, 17)

輸出如下：

13 和 17 的二進位制形式：
0b1101 0b10001

13 和 17 的位與：
1

你可以使用下表驗證此輸出。考慮下面的位與真值表。

A	B	AND
1	1	1
1	0	0
0	1	0
0	0	0

| | | 1 | 1 | 0 | 1 |
| --- | --- |
| AND |
| | 1 | 0 | 0 | 0 | 1 |
| result | 0 | 0 | 0 | 0 | 1 |

`bitwise_or`

通過np.bitwise_or()函式對輸入陣列中的整數的二進位制表示的相應位執行位或運算。

例子

import numpy as np 
a,b = 13,17 
print '13 和 17 的二進位制形式：' 
print bin(a), bin(b)  

print '13 和 17 的位或：' 
print np.bitwise_or(13, 17)

輸出如下：

13 和 17 的二進位制形式：
0b1101 0b10001

13 和 17 的位或：
29

你可以使用下表驗證此輸出。考慮下面的位或真值表。

A	B	OR
1	1	1
1	0	1
0	1	1
0	0	0

| | | 1 | 1 | 0 | 1 |
| --- | --- |
| OR |
| | 1 | 0 | 0 | 0 | 1 |
| result | 1 | 1 | 1 | 0 | 1 |

`invert`

此函式計算輸入陣列中整數的位非結果。對於有符號整數，返回補碼。

例子

import numpy as np 

print '13 的位反轉，其中 ndarray 的 dtype 是 uint8：' 
print np.invert(np.array([13], dtype = np.uint8)) 
print '\n'  
# 比較 13 和 242 的二進位制表示，我們發現了位的反轉

print '13 的二進位制表示：' 
print np.binary_repr(13, width = 8) 
print '\n'  

print '242 的二進位制表示：' 
print np.binary_repr(242, width = 8)

輸出如下：

13 的位反轉，其中 ndarray 的 dtype 是 uint8：
[242]

13 的二進位制表示：
00001101

242 的二進位制表示：
11110010

請注意，np.binary_repr()函式返回給定寬度中十進位制數的二進位制表示。

`left_shift`

numpy.left shift()函式將陣列元素的二進位制表示中的位向左移動到指定位置，右側附加相等數量的 0。

例如，

import numpy as np 

print '將 10 左移兩位：' 
print np.left_shift(10,2) 
print '\n'  

print '10 的二進位制表示：' 
print np.binary_repr(10, width = 8) 
print '\n'  

print '40 的二進位制表示：' 
print np.binary_repr(40, width = 8)  
#  '00001010' 中的兩位移動到了左邊，並在右邊新增了兩個 0。

輸出如下：

將 10 左移兩位：
40

10 的二進位制表示：
00001010

40 的二進位制表示：
00101000

`right_shift`

numpy.right_shift()函式將陣列元素的二進位制表示中的位向右移動到指定位置，左側附加相等數量的 0。

import numpy as np 

print '將 40 右移兩位：' 
print np.right_shift(40,2) 
print '\n'  

print '40 的二進位制表示：' 
print np.binary_repr(40, width = 8) 
print '\n'  

print '10 的二進位制表示：' 
print np.binary_repr(10, width = 8)  
#  '00001010' 中的兩位移動到了右邊，並在左邊新增了兩個 0。

輸出如下：

將 40 右移兩位：
10

40 的二進位制表示：
00101000

10 的二進位制表示：
00001010

NumPy - 字串函式

以下函式用於對dtype為numpy.string_或numpy.unicode_的陣列執行向量化字串操作。它們基於 Python 內建庫中的標準字串函式。

序號	函式及描述
1.	`add()` 返回兩個`str`或`Unicode`陣列的逐個字串連線
2.	`multiply()` 返回按元素多重連線後的字串
3.	`center()` 返回給定字串的副本，其中元素位於特定字串的中央
4.	`capitalize()` 返回給定字串的副本，其中只有第一個字串大寫
5.	`title()` 返回字串或 Unicode 的按元素標題轉換版本
6.	`lower()` 返回一個陣列，其元素轉換為小寫
7.	`upper()` 返回一個陣列，其元素轉換為大寫
8.	`split()` 返回字串中的單詞列表，並使用分隔符來分割
9.	`splitlines()` 返回元素中的行列表，以換行符分割
10.	`strip()` 返回陣列副本，其中元素移除了開頭或者結尾處的特定字元
11.	`join()` 返回一個字串，它是序列中字串的連線
12.	`replace()` 返回字串的副本，其中所有子字串的出現位置都被新字串取代
13.	`decode()` 按元素呼叫`str.decode`
14.	`encode()` 按元素呼叫`str.encode`

這些函式在字元陣列類（numpy.char）中定義。較舊的 Numarray 包包含chararray類。 numpy.char類中的上述函式在執行向量化字串操作時非常有用。

`numpy.char.add()`

函式執行按元素的字串連線。

import numpy as np 
print '連線兩個字串：' 
print np.char.add(['hello'],[' xyz']) 
print '\n'

print '連線示例：' 
print np.char.add(['hello', 'hi'],[' abc', ' xyz'])

輸出如下：

連線兩個字串：
['hello xyz']

連線示例：
['hello abc' 'hi xyz']

`numpy.char.multiply()`

這個函式執行多重連線。

import numpy as np 
print np.char.multiply('Hello ',3)

輸出如下：

Hello Hello Hello

`numpy.char.center()`

此函式返回所需寬度的陣列，以便輸入字串位於中心，並使用fillchar在左側和右側進行填充。

import numpy as np 
# np.char.center(arr, width,fillchar) 
print np.char.center('hello', 20,fillchar = '*')

輸出如下：

*******hello********

`numpy.char.capitalize()`

函式返回字串的副本，其中第一個字母大寫

import numpy as np 
print np.char.capitalize('hello world')

輸出如下：

Hello world

`numpy.char.title()`

返回輸入字串的按元素標題轉換版本，其中每個單詞的首字母都大寫。

import numpy as np 
print np.char.title('hello how are you?')

輸出如下：

Hello How Are You?

`numpy.char.lower()`

函式返回一個陣列，其元素轉換為小寫。它對每個元素呼叫str.lower。

import numpy as np 
print np.char.lower(['HELLO','WORLD']) 
print np.char.lower('HELLO')

輸出如下：

['hello' 'world']
hello

`numpy.char.upper()`

函式返回一個陣列，其元素轉換為大寫。它對每個元素呼叫str.upper。

import numpy as np 
print np.char.upper('hello') 
print np.char.upper(['hello','world'])

輸出如下：

HELLO
['HELLO' 'WORLD']

`numpy.char.split()`

此函式返回輸入字串中的單詞列表。預設情況下，空格用作分隔符。否則，指定的分隔符字元用於分割字串。

import numpy as np 
print np.char.split ('hello how are you?') 
print np.char.split ('TutorialsPoint,Hyderabad,Telangana', sep = ',')

輸出如下：

['hello', 'how', 'are', 'you?']
['TutorialsPoint', 'Hyderabad', 'Telangana']

`numpy.char.splitlines()`

函式返回陣列中元素的單詞列表，以換行符分割。

import numpy as np 
print np.char.splitlines('hello\nhow are you?') 
print np.char.splitlines('hello\rhow are you?')

輸出如下：

['hello', 'how are you?']
['hello', 'how are you?']

'\n'，'\r'，'\r\n'都會用作換行符。

`numpy.char.strip()`

函式返回陣列的副本，其中元素移除了開頭或結尾處的特定字元。

import numpy as np 
print np.char.strip('ashok arora','a') 
print np.char.strip(['arora','admin','java'],'a')

輸出如下：

shok aror
['ror' 'dmin' 'jav']

`numpy.char.join()`

這個函式返回一個字串，其中單個字元由特定的分隔符連線。

import numpy as np 
print np.char.join(':','dmy') 
print np.char.join([':','-'],['dmy','ymd'])

輸出如下：

d:m:y
['d:m:y' 'y-m-d']

`numpy.char.replace()`

這個函式返回字串副本，其中所有字元序列的出現位置都被另一個給定的字元序列取代。

import numpy as np 
print np.char.replace ('He is a good boy', 'is', 'was')

輸出如下：

He was a good boy

`numpy.char.decode()`

這個函式在給定的字串中使用特定編碼呼叫str.decode()。

import numpy as np 

a = np.char.encode('hello', 'cp500') 
print a 
print np.char.decode(a,'cp500')

輸出如下：

\x88\x85\x93\x93\x96
hello

`numpy.char.encode()`

此函式對陣列中的每個元素呼叫str.encode函式。預設編碼是utf_8，可以使用標準 Python 庫中的編解碼器。

import numpy as np 
a = np.char.encode('hello', 'cp500') 
print a

輸出如下：

\x88\x85\x93\x93\x96

NumPy - 算數函式

很容易理解的是，NumPy 包含大量的各種數學運算功能。 NumPy 提供標準的三角函式，算術運算的函式，複數處理函式等。

三角函式

NumPy 擁有標準的三角函式，它為弧度制單位的給定角度返回三角函式比值。

示例

import numpy as np
a = np.array([0,30,45,60,90])  
print  '不同角度的正弦值：'  
# 通過乘 pi/180 轉化為弧度  
print np.sin(a*np.pi/180)  
print  '\n'  
print  '陣列中角度的餘弦值：'  
print np.cos(a*np.pi/180)  
print  '\n'  
print  '陣列中角度的正切值：'  
print np.tan(a*np.pi/180)

輸出如下：

不同角度的正弦值：                                                   
[ 0.          0.5         0.70710678  0.8660254   1.        ]                 

陣列中角度的餘弦值：                                         
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
   6.12323400e-17]                                                            

陣列中角度的正切值：                                            
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
   1.63312394e+16]

arcsin，arccos，和arctan函式返回給定角度的sin，cos和tan的反三角函式。這些函式的結果可以通過numpy.degrees()函式通過將弧度制轉換為角度制來驗證。

示例

import numpy as np
a = np.array([0,30,45,60,90])  
print  '含有正弦值的陣列：'
sin = np.sin(a*np.pi/180)  
print sin
print  '\n'  
print  '計算角度的反正弦，返回值以弧度為單位：'
inv = np.arcsin(sin)  
print inv
print  '\n'  
print  '通過轉化為角度制來檢查結果：'  
print np.degrees(inv)  
print  '\n'  
print  'arccos 和 arctan 函式行為類似：'
cos = np.cos(a*np.pi/180)  
print cos
print  '\n'  
print  '反餘弦：'
inv = np.arccos(cos)  
print inv
print  '\n'  
print  '角度制單位：'  
print np.degrees(inv)  
print  '\n'  
print  'tan 函式：'
tan = np.tan(a*np.pi/180)  
print tan
print  '\n'  
print  '反正切：'
inv = np.arctan(tan)  
print inv
print  '\n'  
print  '角度制單位：'  
print np.degrees(inv)

輸出如下：

含有正弦值的陣列：
[ 0.          0.5         0.70710678  0.8660254   1.        ]

計算角度的反正弦，返回值以弧度製為單位：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]

通過轉化為角度制來檢查結果：
[  0.  30.  45.  60.  90.]

arccos 和 arctan 函式行為類似：
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
   6.12323400e-17]

反餘弦：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]

角度制單位：
[  0.  30.  45.  60.  90.]

tan 函式：
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
   1.63312394e+16]

反正切：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]

角度制單位：
[  0.  30.  45.  60.  90.]

舍入函式

`numpy.around()`

這個函式返回四捨五入到所需精度的值。該函式接受以下引數。

numpy.around(a,decimals)

其中：

序號	引數及描述
1.	`a` 輸入陣列
2.	`decimals` 要舍入的小數位數。預設值為0。如果為負，整數將四捨五入到小數點左側的位置

示例

import numpy as np
a = np.array([1.0,5.55,  123,  0.567,  25.532])  
print  '原陣列：'  
print a
print  '\n'  
print  '舍入後：'  
print np.around(a)  
print np.around(a, decimals =  1)  
print np.around(a, decimals =  -1)

輸出如下：

原陣列：                                                          
[   1.       5.55   123.       0.567   25.532]

舍入後：                                                         
[   1.    6.   123.    1.   26. ]                                               
[   1.    5.6  123.    0.6  25.5]                                          
[   0.    10.  120.    0.   30. ]

`numpy.floor()`

此函式返回不大於輸入引數的最大整數。即標量x 的下限是最大的整數i ，使得i <= x。注意在Python中，向下取整總是從 0 舍入。

示例

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  '提供的陣列：'  
print a
print  '\n'  
print  '修改後的陣列：'  
print np.floor(a)

輸出如下：

提供的陣列：                                                            
[ -1.7   1.5  -0.2   0.6  10. ]

修改後的陣列：                                                         
[ -2.   1.  -1.   0.  10.]

`numpy.ceil()`

ceil()函式返回輸入值的上限，即，標量x的上限是最小的整數i ，使得i> = x。

示例

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  '提供的陣列：'  
print a
print  '\n'  
print  '修改後的陣列：'  
print np.ceil(a)

輸出如下：

提供的陣列：
[ -1.7   1.5  -0.2   0.6  10. ]

修改後的陣列：
[ -1.   2.  -0.   1.  10.]

NumPy - 算數運算

用於執行算術運算（如add()，subtract()，multiply()和divide()）的輸入陣列必須具有相同的形狀或符合陣列廣播規則。

示例

import numpy as np 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print  '第一個陣列：'  
print a 
print  '\n'  
print  '第二個陣列：' 
b = np.array([10,10,10])  
print b 
print  '\n'  
print  '兩個陣列相加：'  
print np.add(a,b)  
print  '\n'  
print  '兩個陣列相減：'  
print np.subtract(a,b)  
print  '\n'  
print  '兩個陣列相乘：'  
print np.multiply(a,b)  
print  '\n'  
print  '兩個陣列相除：'  
print np.divide(a,b)

輸出如下：

第一個陣列：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

第二個陣列：
[10 10 10]

兩個陣列相加：
[[ 10. 11. 12.]
 [ 13. 14. 15.]
 [ 16. 17. 18.]]

兩個陣列相減：
[[-10. -9. -8.]
 [ -7. -6. -5.]
 [ -4. -3. -2.]]

兩個陣列相乘：
[[ 0. 10. 20.]
 [ 30. 40. 50.]
 [ 60. 70. 80.]]

兩個陣列相除：
[[ 0. 0.1 0.2]
 [ 0.3 0.4 0.5]
 [ 0.6 0.7 0.8]]

讓我們現在來討論 NumPy 中提供的一些其他重要的算術函式。

`numpy.reciprocal()`

此函式返回引數逐元素的倒數，。由於 Python 處理整數除法的方式，對於絕對值大於 1 的整數元素，結果始終為 0，對於整數 0，則發出溢位警告。

示例

import numpy as np 
a = np.array([0.25,  1.33,  1,  0,  100])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 reciprocal 函式：'  
print np.reciprocal(a)  
print  '\n' 
b = np.array([100], dtype =  int)  
print  '第二個陣列：'  
print b 
print  '\n'  
print  '呼叫 reciprocal 函式：'  
print np.reciprocal(b)

輸出如下：

我們的陣列是：                                                               
[   0.25    1.33    1.      0.    100.  ]                                     

呼叫 reciprocal 函式：                                         
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal           
  print np.reciprocal(a)                                                      
[ 4.         0.7518797  1.               inf  0.01     ]                      

第二個陣列：                                                      
[100]                                                                         

呼叫 reciprocal 函式：                                        
[0]

`numpy.power()`

此函式將第一個輸入陣列中的元素作為底數，計算它與第二個輸入陣列中相應元素的冪。

import numpy as np 
a = np.array([10,100,1000])  
print  '我們的陣列是；'  
print a 
print  '\n'  
print  '呼叫 power 函式：'  
print np.power(a,2)  
print  '\n'  
print  '第二個陣列：' 
b = np.array([1,2,3])  
print b 
print  '\n'  
print  '再次呼叫 power 函式：'  
print np.power(a,b)

輸出如下：

我們的陣列是；                                                              
[  10  100 1000]                                                              

呼叫 power 函式：                                                    
[    100   10000 1000000]                                                     

第二個陣列：                                                              
[1 2 3]                                                                       

再次呼叫 power 函式：                                              
[        10      10000 1000000000]

`numpy.mod()`

此函式返回輸入陣列中相應元素的除法餘數。函式numpy.remainder()也產生相同的結果。

import numpy as np 
a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print  '第一個陣列：'  
print a 
print  '\n'  
print  '第二個陣列：'  
print b 
print  '\n' 
print  '呼叫 mod() 函式：'  
print np.mod(a,b)  
print  '\n'  
print  '呼叫 remainder() 函式：'  
print np.remainder(a,b)

輸出如下：

第一個陣列：
[10 20 30]

第二個陣列：
[3 5 7]

呼叫 mod() 函式：                                                     
[1 0 2]

呼叫 remainder() 函式：                                              
[1 0 2]

以下函式用於對含有複數的陣列執行操作。

numpy.real() 返回複數型別引數的實部。
numpy.imag() 返回複數型別引數的虛部。
numpy.conj() 返回通過改變虛部的符號而獲得的共軛複數。
numpy.angle() 返回複數引數的角度。函式的引數是degree。如果為true，返回的角度以角度制來表示，否則為以弧度制來表示。

import numpy as np 
a = np.array([-5.6j,  0.2j,  11.  ,  1+1j])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 real() 函式：'  
print np.real(a)  
print  '\n'  
print  '呼叫 imag() 函式：'  
print np.imag(a)  
print  '\n'  
print  '呼叫 conj() 函式：'  
print np.conj(a)  
print  '\n'  
print  '呼叫 angle() 函式：'  
print np.angle(a)  
print  '\n'  
print  '再次呼叫 angle() 函式（以角度制返回）：'  
print np.angle(a, deg =  True)

輸出如下：

我們的陣列是：
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]

呼叫 real() 函式：
[ 0. 0. 11. 1.]

呼叫 imag() 函式：
[-5.6 0.2 0. 1. ]

呼叫 conj() 函式：
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]

呼叫 angle() 函式：
[-1.57079633 1.57079633 0. 0.78539816]

再次呼叫 angle() 函式（以角度制返回）：
[-90. 90. 0. 45.]

NumPy - 統計函式

NumPy 有很多有用的統計函式，用於從陣列中給定的元素中查詢最小，最大，百分標準差和方差等。函式說明如下：

`numpy.amin()` 和 `numpy.amax()`

這些函式從給定陣列中的元素沿指定軸返回最小值和最大值。

示例

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 amin() 函式：'  
print np.amin(a,1)  
print  '\n'  
print  '再次呼叫 amin() 函式：'  
print np.amin(a,0)  
print  '\n'  
print  '呼叫 amax() 函式：'  
print np.amax(a)  
print  '\n'  
print  '再次呼叫 amax() 函式：'  
print np.amax(a, axis =  0)

輸出如下：

我們的陣列是：
[[3 7 5]
[8 4 3]
[2 4 9]]

呼叫 amin() 函式：
[3 3 2]

再次呼叫 amin() 函式：
[2 4 3]

呼叫 amax() 函式：
9

再次呼叫 amax() 函式：
[8 7 9]

`numpy.ptp()`

numpy.ptp()函式返回沿軸的值的範圍（最大值 - 最小值）。

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 ptp() 函式：'  
print np.ptp(a)  
print  '\n'  
print  '沿軸 1 呼叫 ptp() 函式：'  
print np.ptp(a, axis =  1)  
print  '\n'  
print  '沿軸 0 呼叫 ptp() 函式：'  
print np.ptp(a, axis =  0)

輸出如下：

我們的陣列是：
[[3 7 5]
[8 4 3]
[2 4 9]]

呼叫 ptp() 函式：
7

沿軸 1 呼叫 ptp() 函式：
[4 5 7]

沿軸 0 呼叫 ptp() 函式：
[6 3 6]

`numpy.percentile()`

百分位數是統計中使用的度量，表示小於這個值得觀察值佔某個百分比。函式numpy.percentile()接受以下引數。

numpy.percentile(a, q, axis)

其中：

序號	引數及描述
1.	`a` 輸入陣列
2.	`q` 要計算的百分位數，在 0 ~ 100 之間
3.	`axis` 沿著它計算百分位數的軸

示例

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 percentile() 函式：'  
print np.percentile(a,50)  
print  '\n'  
print  '沿軸 1 呼叫 percentile() 函式：'  
print np.percentile(a,50, axis =  1)  
print  '\n'  
print  '沿軸 0 呼叫 percentile() 函式：'  
print np.percentile(a,50, axis =  0)

輸出如下：

我們的陣列是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]

呼叫 percentile() 函式：
50.0

沿軸 1 呼叫 percentile() 函式：
[ 40. 20. 60.]

沿軸 0 呼叫 percentile() 函式：
[ 50. 40. 60.]

`numpy.median()`

中值定義為將資料樣本的上半部分與下半部分分開的值。 numpy.median()函式的用法如下面的程式所示。

示例

import numpy as np 
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 median() 函式：'  
print np.median(a)  
print  '\n'  
print  '沿軸 0 呼叫 median() 函式：'  
print np.median(a, axis =  0)  
print  '\n'  
print  '沿軸 1 呼叫 median() 函式：'  
print np.median(a, axis =  1)

輸出如下：

我們的陣列是：
[[30 65 70]
 [80 95 10]
 [50 90 60]]

呼叫 median() 函式：
65.0

沿軸 0 呼叫 median() 函式：
[ 50. 90. 60.]

沿軸 1 呼叫 median() 函式：
[ 65. 80. 60.]

`numpy.mean()`

算術平均值是沿軸的元素的總和除以元素的數量。 numpy.mean()函式返回陣列中元素的算術平均值。如果提供了軸，則沿其計算。

示例

import numpy as np 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 mean() 函式：'  
print np.mean(a)  
print  '\n'  
print  '沿軸 0 呼叫 mean() 函式：'  
print np.mean(a, axis =  0)  
print  '\n'  
print  '沿軸 1 呼叫 mean() 函式：'  
print np.mean(a, axis =  1)

輸出如下：

我們的陣列是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]

呼叫 mean() 函式：
3.66666666667

沿軸 0 呼叫 mean() 函式：
[ 2.66666667 3.66666667 4.66666667]

沿軸 1 呼叫 mean() 函式：
[ 2. 4. 5.]

`numpy.average()`

加權平均值是由每個分量乘以反映其重要性的因子得到的平均值。 numpy.average()函式根據在另一個陣列中給出的各自的權重計算陣列中元素的加權平均值。該函式可以接受一個軸引數。如果沒有指定軸，則陣列會被展開。

考慮陣列[1,2,3,4]和相應的權重[4,3,2,1]，通過將相應元素的乘積相加，並將和除以權重的和，來計算加權平均值。

加權平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)

示例

import numpy as np 
a = np.array([1,2,3,4])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 average() 函式：'  
print np.average(a)  
print  '\n'  
# 不指定權重時相當於 mean 函式
wts = np.array([4,3,2,1])  
print  '再次呼叫 average() 函式：'  
print np.average(a,weights = wts)  
print  '\n'  
# 如果 returned 引數設為 true，則返回權重的和  
print  '權重的和：'  
print np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True)

輸出如下：

我們的陣列是：
[1 2 3 4]

呼叫 average() 函式：
2.5

再次呼叫 average() 函式：
2.0

權重的和：
(2.0, 10.0)

在多維陣列中，可以指定用於計算的軸。

示例

import numpy as np 
a = np.arange(6).reshape(3,2)  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '修改後的陣列：' 
wt = np.array([3,5])  
print np.average(a, axis =  1, weights = wt)  
print  '\n'  
print  '修改後的陣列：'  
print np.average(a, axis =  1, weights = wt, returned =  True)

輸出如下：

我們的陣列是：
[[0 1]
 [2 3]
 [4 5]]

修改後的陣列：
[ 0.625 2.625 4.625]

修改後的陣列：
(array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))

標準差

標準差是與均值的偏差的平方的平均值的平方根。標準差公式如下：

std = sqrt(mean((x - x.mean())**2))

如果陣列是[1，2，3，4]，則其平均值為2.5。因此，差的平方是[2.25,0.25,0.25,2.25]，並且其平均值的平方根除以4，即sqrt(5/4)是1.1180339887498949。

示例

import numpy as np 
print np.std([1,2,3,4])

輸出如下：

1.1180339887498949

方差

方差是偏差的平方的平均值，即mean((x - x.mean())** 2)。換句話說，標準差是方差的平方根。

示例

import numpy as np 
print np.var([1,2,3,4])

輸出如下：

1.25

NumPy - 排序、搜尋和計數函式

NumPy中提供了各種排序相關功能。這些排序函式實現不同的排序演算法，每個排序演算法的特徵在於執行速度，最壞情況效能，所需的工作空間和演算法的穩定性。下表顯示了三種排序演算法的比較。

種類	速度	最壞情況	工作空間	穩定性
`'quicksort'`（快速排序）	1	`O(n^2)`	0	否
`'mergesort'`（歸併排序）	2	`O(n*log(n))`	~n/2	是
`'heapsort'`（堆排序）	3	`O(n*log(n))`	0	否

`numpy.sort()`

sort()函式返回輸入陣列的排序副本。它有以下引數：

numpy.sort(a, axis, kind, order)

其中：

序號	引數及描述
1.	`a` 要排序的陣列
2.	`axis` 沿著它排序陣列的軸，如果沒有陣列會被展開，沿著最後的軸排序
3.	`kind` 預設為`'quicksort'`（快速排序）
4.	`order` 如果陣列包含欄位，則是要排序的欄位

示例

import numpy as np  
a = np.array([[3,7],[9,1]])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 sort() 函式：'  
print np.sort(a)  
print  '\n'  
print  '沿軸 0 排序：'  
print np.sort(a, axis =  0)  
print  '\n'  
# 在 sort 函式中排序欄位 
dt = np.dtype([('name',  'S10'),('age',  int)]) 
a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '按 name 排序：'  
print np.sort(a, order =  'name')

輸出如下：

我們的陣列是：
[[3 7]
 [9 1]]

呼叫 sort() 函式：
[[3 7]
 [1 9]]

沿軸 0 排序：
[[3 1]
 [9 7]]

我們的陣列是：
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]

按 name 排序：
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]

`numpy.argsort()`

numpy.argsort()函式對輸入陣列沿給定軸執行間接排序，並使用指定排序型別返回資料的索引陣列。這個索引陣列用於構造排序後的陣列。

示例

import numpy as np 
x = np.array([3,  1,  2])  
print  '我們的陣列是：'  
print x 
print  '\n'  
print  '對 x 呼叫 argsort() 函式：' 
y = np.argsort(x)  
print y 
print  '\n'  
print  '以排序後的順序重構原陣列：'  
print x[y]  
print  '\n'  
print  '使用迴圈重構原陣列：'  
for i in y:  
    print x[i],

輸出如下：

我們的陣列是：
[3 1 2]

對 x 呼叫 argsort() 函式：
[1 2 0]

以排序後的順序重構原陣列：
[1 2 3]

使用迴圈重構原陣列：
1 2 3

`numpy.lexsort()`

函式使用鍵序列執行間接排序。鍵可以看作是電子表格中的一列。該函式返回一個索引陣列，使用它可以獲得排序資料。注意，最後一個鍵恰好是 sort 的主鍵。

示例

import numpy as np 

nm =  ('raju','anil','ravi','amar') 
dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
ind = np.lexsort((dv,nm))  
print  '呼叫 lexsort() 函式：'  
print ind 
print  '\n'  
print  '使用這個索引來獲取排序後的資料：'  
print  [nm[i]  +  ", "  + dv[i]  for i in ind]

輸出如下：

呼叫 lexsort() 函式：
[3 1 0 2]

使用這個索引來獲取排序後的資料：
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

NumPy 模組有一些用於在陣列內搜尋的函式。提供了用於找到最大值，最小值以及滿足給定條件的元素的函式。

`numpy.argmax()` 和 `numpy.argmin()`

這兩個函式分別沿給定軸返回最大和最小元素的索引。

示例

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 argmax() 函式：'  
print np.argmax(a)  
print  '\n'  
print  '展開陣列：'  
print a.flatten()  
print  '\n'  
print  '沿軸 0 的最大值索引：' 
maxindex = np.argmax(a, axis =  0)  
print maxindex 
print  '\n'  
print  '沿軸 1 的最大值索引：' 
maxindex = np.argmax(a, axis =  1)  
print maxindex 
print  '\n'  
print  '呼叫 argmin() 函式：' 
minindex = np.argmin(a)  
print minindex 
print  '\n'  
print  '展開陣列中的最小值：'  
print a.flatten()[minindex]  
print  '\n'  
print  '沿軸 0 的最小值索引：' 
minindex = np.argmin(a, axis =  0)  
print minindex 
print  '\n'  
print  '沿軸 1 的最小值索引：' 
minindex = np.argmin(a, axis =  1)  
print minindex

輸出如下：

我們的陣列是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]

呼叫 argmax() 函式：
7

展開陣列：
[30 40 70 80 20 10 50 90 60]

沿軸 0 的最大值索引：
[1 2 0]

沿軸 1 的最大值索引：
[2 0 1]

呼叫 argmin() 函式：
5

展開陣列中的最小值：
10

沿軸 0 的最小值索引：
[0 1 1]

沿軸 1 的最小值索引：
[0 2 0]

`numpy.nonzero()`

numpy.nonzero()函式返回輸入陣列中非零元素的索引。

示例

import numpy as np 
a = np.array([[30,40,0],[0,20,10],[50,0,60]])  
print  '我們的陣列是：'  
print a 
print  '\n'  
print  '呼叫 nonzero() 函式：'  
print np.nonzero (a)

輸出如下：

我們的陣列是：
[[30 40 0]
 [ 0 20 10]
 [50 0 60]]

呼叫 nonzero() 函式：
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

`numpy.where()`

where()函式返回輸入陣列中滿足給定條件的元素的索引。

示例

import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print  '我們的陣列是：'  
print x 
print  '大於 3 的元素的索引：' 
y = np.where(x >  3)  
print y 
print  '使用這些索引來獲取滿足條件的元素：'  
print x[y]

輸出如下：

我們的陣列是：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

大於 3 的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

使用這些索引來獲取滿足條件的元素：
[ 4. 5. 6. 7. 8.]

`numpy.extract()`

extract()函式返回滿足任何條件的元素。

import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print  '我們的陣列是：'  
print x 
# 定義條件 
condition = np.mod(x,2)  ==  0  
print  '按元素的條件值：'  
print condition 
print  '使用條件提取元素：'  
print np.extract(condition, x)

輸出如下：

我們的陣列是：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

按元素的條件值：
[[ True False True]
 [False True False]
 [ True False True]]

使用條件提取元素：
[ 0. 2. 4. 6. 8.]

NumPy - 位元組交換

我們已經看到，儲存在計算機記憶體中的資料取決於 CPU 使用的架構。它可以是小端（最小有效位儲存在最小地址中）或大端（最小有效位元組儲存在最大地址中）。

`numpy.ndarray.byteswap()`

numpy.ndarray.byteswap()函式在兩個表示：大端和小端之間切換。

import numpy as np 
a = np.array([1,  256,  8755], dtype = np.int16)  
print  '我們的陣列是：'  
print a 
print  '以十六進位制表示記憶體中的資料：'  
print map(hex,a)  
# byteswap() 函式通過傳入 true 來原地交換 
print  '呼叫 byteswap() 函式：'  
print a.byteswap(True)  
print  '十六進位制形式：'  
print map(hex,a)  
# 我們可以看到位元組已經交換了

輸出如下：

我們的陣列是：
[1 256 8755]

以十六進位制表示記憶體中的資料：
['0x1', '0x100', '0x2233']

呼叫 byteswap() 函式：
[256 1 13090]

十六進位制形式：
['0x100', '0x1', '0x3322']

NumPy - 副本和檢視

在執行函式時，其中一些返回輸入陣列的副本，而另一些返回檢視。當內容物理儲存在另一個位置時，稱為副本。另一方面，如果提供了相同記憶體內容的不同檢視，我們將其稱為檢視。

無複製

簡單的賦值不會建立陣列物件的副本。相反，它使用原始陣列的相同id()來訪問它。 id()返回 Python 物件的通用識別符號，類似於 C 中的指標。

此外，一個陣列的任何變化都反映在另一個陣列上。例如，一個陣列的形狀改變也會改變另一個陣列的形狀。

示例

import numpy as np 
a = np.arange(6)  
print  '我們的陣列是：'  
print a 
print  '呼叫 id() 函式：'  
print id(a)  
print  'a 賦值給 b：' 
b = a 
print b 
print  'b 擁有相同 id()：'  
print id(b)  
print  '修改 b 的形狀：' 
b.shape =  3,2  
print b 
print  'a 的形狀也修改了：'  
print a

輸出如下：

我們的陣列是：
[0 1 2 3 4 5]

呼叫 id() 函式：
139747815479536

a 賦值給 b：
[0 1 2 3 4 5]
b 擁有相同 id()：
139747815479536

修改 b 的形狀：
[[0 1]
 [2 3]
 [4 5]]

a 的形狀也修改了：
[[0 1]
 [2 3]
 [4 5]]

檢視或淺複製

NumPy 擁有ndarray.view()方法，它是一個新的陣列物件，並可檢視原始陣列的相同資料。與前一種情況不同，新陣列的維數更改不會更改原始資料的維數。

示例

import numpy as np 
# 最開始 a 是個 3X2 的陣列
a = np.arange(6).reshape(3,2)  
print  '陣列 a：'  
print a 
print  '建立 a 的檢視：' 
b = a.view()  
print b 
print  '兩個陣列的 id() 不同：'  
print  'a 的 id()：'  
print id(a)  
print  'b 的 id()：'  
print id(b)  
# 修改 b 的形狀，並不會修改 a
b.shape =  2,3  
print  'b 的形狀：'  
print b 
print  'a 的形狀：'  
print a

輸出如下：

陣列 a：
[[0 1]
 [2 3]
 [4 5]]

建立 a 的檢視：
[[0 1]
 [2 3]
 [4 5]]

兩個陣列的 id() 不同：
a 的 id()：
140424307227264
b 的 id()：
140424151696288

b 的形狀：
[[0 1 2]
 [3 4 5]]

a 的形狀：
[[0 1]
 [2 3]
 [4 5]]

陣列的切片也會建立檢視：

示例

import numpy as np 
a = np.array([[10,10],  [2,3],  [4,5]])  
print  '我們的陣列：'  
print a 
print  '建立切片：' 
s = a[:,  :2]  
print s

輸出如下：

我們的陣列：
[[10 10]
 [ 2 3]
 [ 4 5]]

建立切片：
[[10 10]
 [ 2 3]
 [ 4 5]]

深複製

ndarray.copy()函式建立一個深層副本。它是陣列及其資料的完整副本，不與原始陣列共享。

示例

import numpy as np 
a = np.array([[10,10],  [2,3],  [4,5]])  
print  '陣列 a：'  
print a 
print  '建立 a 的深層副本：' 
b = a.copy()  
print  '陣列 b：'  
print b 
# b 與 a 不共享任何內容  
print  '我們能夠寫入 b 來寫入 a 嗎？'  
print b is a 
print  '修改 b 的內容：' 
b[0,0]  =  100  
print  '修改後的陣列 b：'  
print b 
print  'a 保持不變：'  
print a

輸出如下：

陣列 a：
[[10 10]
 [ 2 3]
 [ 4 5]]

建立 a 的深層副本：
陣列 b：
[[10 10]
 [ 2 3]
 [ 4 5]]
我們能夠寫入 b 來寫入 a 嗎？
False

修改 b 的內容：
修改後的陣列 b：
[[100 10]
 [ 2 3]
 [ 4 5]]

a 保持不變：
[[10 10]
 [ 2 3]
 [ 4 5]]

NumPy - 矩陣庫

NumPy 包包含一個 Matrix庫numpy.matlib。此模組的函式返回矩陣而不是返回ndarray物件。

`matlib.empty()`

matlib.empty()函式返回一個新的矩陣，而不初始化元素。該函式接受以下引數。

numpy.matlib.empty(shape, dtype, order)

其中：

序號	引數及描述
1.	`shape` 定義新矩陣形狀的整數或整數元組
2.	`Dtype` 可選，輸出的資料型別
3.	`order` `C` 或者 `F`

示例

import numpy.matlib 
import numpy as np 
print np.matlib.empty((2,2))  
# 填充為隨機資料

輸出如下：

[[ 2.12199579e-314,   4.24399158e-314] 
 [ 4.24399158e-314,   2.12199579e-314]]

`numpy.matlib.zeros()`

此函式返回以零填充的矩陣。

import numpy.matlib 
import numpy as np 
print np.matlib.zeros((2,2))

輸出如下：

[[ 0.  0.] 
 [ 0.  0.]])

`numpy.matlib.ones()`

此函式返回以一填充的矩陣。

import numpy.matlib 
import numpy as np 
print np.matlib.ones((2,2))

輸出如下：

[[ 1.  1.] 
 [ 1.  1.]]

`numpy.matlib.eye()`

這個函式返回一個矩陣，對角線元素為 1，其他位置為零。該函式接受以下引數。

numpy.matlib.eye(n, M,k, dtype)

其中：

序號	引數及描述
1.	`n` 返回矩陣的行數
2.	`M` 返回矩陣的列數，預設為`n`
3.	`k` 對角線的索引
4.	`dtype` 輸出的資料型別

示例

import numpy.matlib 
import numpy as np 
print np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float)

輸出如下：

[[ 1.  0.  0.  0.] 
 [ 0.  1.  0.  0.] 
 [ 0.  0.  1.  0.]])

`numpy.matlib.identity()`

numpy.matlib.identity()函式返回給定大小的單位矩陣。單位矩陣是主對角線元素都為 1 的方陣。

import numpy.matlib 
import numpy as np 
print np.matlib.identity(5, dtype =  float)

輸出如下：

[[ 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.]]

`numpy.matlib.rand()`

·numpy.matlib.rand()`函式返回給定大小的填充隨機值的矩陣。

示例

import numpy.matlib 
import numpy as np 
print np.matlib.rand(3,3)

輸出如下：

[[ 0.82674464  0.57206837  0.15497519] 
 [ 0.33857374  0.35742401  0.90895076] 
 [ 0.03968467  0.13962089  0.39665201]]

注意，矩陣總是二維的，而ndarray是一個 n 維陣列。兩個物件都是可互換的。

示例

import numpy.matlib 
import numpy as np  

i = np.matrix('1,2;3,4')  
print i

輸出如下：

[[1  2] 
 [3  4]]

示例

import numpy.matlib 
import numpy as np  

j = np.asarray(i)  
print j

輸出如下：

[[1  2] 
 [3  4]]

示例

import numpy.matlib 
import numpy as np  

k = np.asmatrix (j)  
print k

輸出如下：

[[1  2] 
 [3  4]]

NumPy - 線性代數

NumPy 包包含numpy.linalg模組，提供線性代數所需的所有功能。此模組中的一些重要功能如下表所述。

序號	函式及描述
1.	`dot` 兩個陣列的點積
2.	`vdot` 兩個向量的點積
3.	`inner` 兩個陣列的內積
4.	`matmul` 兩個陣列的矩陣積
5.	`determinant` 陣列的行列式
6.	`solve` 求解線性矩陣方程
7.	`inv` 尋找矩陣的乘法逆矩陣

`numpy.dot()`

此函式返回兩個陣列的點積。對於二維向量，其等效於矩陣乘法。對於一維陣列，它是向量的內積。對於 N 維陣列，它是a的最後一個軸上的和與b的倒數第二個軸的乘積。

import numpy.matlib 
import numpy as np 

a = np.array([[1,2],[3,4]]) 
b = np.array([[11,12],[13,14]]) 
np.dot(a,b)

輸出如下：

[[37  40] 
 [85  92]]

要注意點積計算為：

[[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]

`numpy.vdot()`

此函式返回兩個向量的點積。如果第一個引數是複數，那麼它的共軛複數會用於計算。如果引數id是多維陣列，它會被展開。

例子

import numpy as np 
a = np.array([[1,2],[3,4]]) 
b = np.array([[11,12],[13,14]]) 
print np.vdot(a,b)

輸出如下：

注意：1*11 + 2*12 + 3*13 + 4*14 = 130。

`numpy.inner()`

此函式返回一維陣列的向量內積。對於更高的維度，它返回最後一個軸上的和的乘積。

例子

import numpy as np 
print np.inner(np.array([1,2,3]),np.array([0,1,0])) 
# 等價於 1*0+2*1+3*0

輸出如下：

例子

# 多維陣列示例 
import numpy as np 
a = np.array([[1,2], [3,4]]) 

print '陣列 a：' 
print a 
b = np.array([[11, 12], [13, 14]]) 

print '陣列 b：' 
print b 

print '內積：' 
print np.inner(a,b)

輸出如下：

陣列 a：
[[1 2]
[3 4]]

陣列 b：
[[11 12]
[13 14]]

內積：
[[35 41]
[81 95]]

上面的例子中，內積計算如下：

1*11+2*12, 1*13+2*14 
3*11+4*12, 3*13+4*14

`numpy.matmul`

numpy.matmul()函式返回兩個陣列的矩陣乘積。雖然它返回二維陣列的正常乘積，但如果任一引數的維數大於2，則將其視為存在於最後兩個索引的矩陣的棧，並進行相應廣播。

另一方面，如果任一引數是一維陣列，則通過在其維度上附加 1 來將其提升為矩陣，並在乘法之後被去除。

例子

# 對於二維陣列，它就是矩陣乘法
import numpy.matlib 
import numpy as np 

a = [[1,0],[0,1]] 
b = [[4,1],[2,2]] 
print np.matmul(a,b)

輸出如下：

[[4  1] 
 [2  2]]

例子

# 二維和一維運算
import numpy.matlib 
import numpy as np 

a = [[1,0],[0,1]] 
b = [1,2] 
print np.matmul(a,b) 
print np.matmul(b,a)

輸出如下：

[1  2] 
[1  2]

例子

# 維度大於二的陣列 
import numpy.matlib 
import numpy as np 

a = np.arange(8).reshape(2,2,2) 
b = np.arange(4).reshape(2,2) 
print np.matmul(a,b)

輸出如下：

[[[2   3] 
   [6   11]] 
  [[10  19] 
   [14  27]]]

`numpy.linalg.det()`

行列式線上性代數中是非常有用的值。它從方陣的對角元素計算。對於 2×2 矩陣，它是左上和右下元素的乘積與其他兩個的乘積的差。

換句話說，對於矩陣[[a，b]，[c，d]]，行列式計算為ad-bc。較大的方陣被認為是 2×2 矩陣的組合。

numpy.linalg.det()函式計算輸入矩陣的行列式。

例子

import numpy as np
a = np.array([[1,2], [3,4]]) 
print np.linalg.det(a)

輸出如下：

-2.0

例子

b = np.array([[6,1,1], [4, -2, 5], [2,8,7]]) 
print b 
print np.linalg.det(b) 
print 6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2)

輸出如下：

[[ 6 1 1]
 [ 4 -2 5]
 [ 2 8 7]]

-306.0

-306

`numpy.linalg.solve()`

numpy.linalg.solve()函式給出了矩陣形式的線性方程的解。

考慮以下線性方程：

x + y + z = 6

2y + 5z = -4

2x + 5y - z = 27

可以使用矩陣表示為：

如果矩陣成為A、X和B，方程變為：

AX = B

或

X = A^(-1)B

`numpy.linalg.inv()`

我們使用numpy.linalg.inv()函式來計算矩陣的逆。矩陣的逆是這樣的，如果它乘以原始矩陣，則得到單位矩陣。

例子

import numpy as np 

x = np.array([[1,2],[3,4]]) 
y = np.linalg.inv(x) 
print x 
print y 
print np.dot(x,y)

輸出如下：

[[1 2]                                                                        
 [3 4]]                                                                       
[[-2.   1. ]                                                                  
 [ 1.5 -0.5]]                                                                 
[[  1.00000000e+00   1.11022302e-16]                                          
 [  0.00000000e+00   1.00000000e+00]]

例子

現在讓我們在示例中建立一個矩陣A的逆。

import numpy as np 
a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 

print '陣列 a：'
print a 
ainv = np.linalg.inv(a) 

print 'a 的逆：' 
print ainv  

print '矩陣 b：' 
b = np.array([[6],[-4],[27]]) 
print b 

print '計算：A^(-1)B：' 
x = np.linalg.solve(a,b) 
print x  
# 這就是線性方向 x = 5, y = 3, z = -2 的解

輸出如下：

陣列 a：
[[ 1 1 1]
 [ 0 2 5]
 [ 2 5 -1]]

a 的逆：
[[ 1.28571429 -0.28571429 -0.14285714]
 [-0.47619048 0.14285714 0.23809524]
 [ 0.19047619 0.14285714 -0.0952381 ]]

矩陣 b：
[[ 6]
 [-4]
 [27]]

計算：A^(-1)B：
[[ 5.]
 [ 3.]
 [-2.]]

結果也可以使用下列函式獲取

x = np.dot(ainv,b)

NumPy - Matplotlib

Matplotlib 是 Python 的繪相簿。它可與 NumPy 一起使用，提供了一種有效的 MatLab 開源替代方案。它也可以和圖形工具包一起使用，如 PyQt 和 wxPython。

Matplotlib 模組最初是由 John D. Hunter 編寫的。自 2012 年以來，Michael Droettboom 是主要開發者。目前，Matplotlib 1.5.1 是可用的穩定版本。該軟體包可以二進位制分發，其原始碼形式在 www.matplotlib.org 上提供。

通常，通過新增以下語句將包匯入到 Python 指令碼中：

from matplotlib import pyplot as plt

這裡pyplot()是 matplotlib 庫中最重要的函式，用於繪製 2D 資料。以下指令碼繪製方程y = 2x + 5：

示例

import numpy as np 
from matplotlib import pyplot as plt 

x = np.arange(1,11) 
y =  2  * x +  5 
plt.title("Matplotlib demo") 
plt.xlabel("x axis caption") 
plt.ylabel("y axis caption") 
plt.plot(x,y) plt.show()

ndarray物件x由np.arange()函式建立為x軸上的值。y軸上的對應值儲存在另一個陣列物件y中。這些值使用matplotlib軟體包的pyplot子模組的plot()函式繪製。

圖形由show()函式展示。

上面的程式碼應該產生以下輸出：

Matplotlib Demo

作為線性圖的替代，可以通過向plot()函式新增格式字串來顯示離散值。可以使用以下格式化字元。

字元	描述
`'-'`	實線樣式
`'--'`	短橫線樣式
`'-.'`	點劃線樣式
`':'`	虛線樣式
`'.'`	點標記
`','`	畫素標記
`'o'`	圓標記
`'v'`	倒三角標記
`'^'`	正三角標記
`'<'`	左三角標記
`'>'`	右三角標記
`'1'`	下箭頭標記
`'2'`	上箭頭標記
`'3'`	左箭頭標記
`'4'`	右箭頭標記
`'s'`	正方形標記
`'p'`	五邊形標記
`'*'`	星形標記
`'h'`	六邊形標記 1
`'H'`	六邊形標記 2
`'+'`	加號標記
`'x'`	X 標記
`'D'`	菱形標記
`'d'`	窄菱形標記
`'	'`	豎直線標記
`'_'`	水平線標記

還定義了以下顏色縮寫。

字元	顏色
`'b'`	藍色
`'g'`	綠色
`'r'`	紅色
`'c'`	青色
`'m'`	品紅色
`'y'`	黃色
`'k'`	黑色
`'w'`	白色

要顯示圓來代表點，而不是上面示例中的線，請使用ob作為plot()函式中的格式字串。

示例

import numpy as np 
from matplotlib import pyplot as plt 

x = np.arange(1,11) 
y =  2  * x +  5 
plt.title("Matplotlib demo") 
plt.xlabel("x axis caption") 
plt.ylabel("y axis caption") 
plt.plot(x,y,"ob") 
plt.show()

上面的程式碼應該產生以下輸出：

Color Abbreviation

繪製正弦波

以下指令碼使用 matplotlib 生成正弦波圖。

示例

import numpy as np 
import matplotlib.pyplot as plt 
# 計算正弦曲線上點的 x 和 y 座標
x = np.arange(0,  3  * np.pi,  0.1) 
y = np.sin(x)
plt.title("sine wave form")  
# 使用 matplotlib 來繪製點
plt.plot(x, y) 
plt.show()

Sine Wave

`subplot()`

subplot()函式允許你在同一圖中繪製不同的東西。在下面的指令碼中，繪製正弦和餘弦值。

示例

import numpy as np 
import matplotlib.pyplot as plt 
# 計算正弦和餘弦曲線上的點的 x 和 y 座標 
x = np.arange(0,  3  * np.pi,  0.1) 
y_sin = np.sin(x) 
y_cos = np.cos(x)  
# 建立 subplot 網格，高為 2，寬為 1  
# 啟用第一個 subplot
plt.subplot(2,  1,  1)  
# 繪製第一個影像 
plt.plot(x, y_sin) 
plt.title('Sine')  
# 將第二個 subplot 啟用，並繪製第二個影像
plt.subplot(2,  1,  2) 
plt.plot(x, y_cos) 
plt.title('Cosine')  
# 展示影像
plt.show()

上面的程式碼應該產生以下輸出：

Sub Plot

`bar()`

pyplot子模組提供bar()函式來生成條形圖。以下示例生成兩組x和y陣列的條形圖。

示例

from matplotlib import pyplot as plt 
x =  [5,8,10] 
y =  [12,16,6] 
x2 =  [6,9,11] 
y2 =  [6,15,7] 
plt.bar(x, y, align =  'center') 
plt.bar(x2, y2, color =  'g', align =  'center') 
plt.title('Bar graph') 
plt.ylabel('Y axis') 
plt.xlabel('X axis') 
plt.show()

NumPy - 使用 Matplotlib 繪製直方圖

NumPy 有一個numpy.histogram()函式，它是資料的頻率分佈的圖形表示。水平尺寸相等的矩形對應於類間隔，稱為bin，變數height對應於頻率。

`numpy.histogram()`

numpy.histogram()函式將輸入陣列和bin作為兩個引數。 bin陣列中的連續元素用作每個bin的邊界。

import numpy as np 

a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) ]
np.histogram(a,bins =  [0,20,40,60,80,100]) 
hist,bins = np.histogram(a,bins =  [0,20,40,60,80,100])  
print hist 
print bins

輸出如下：

[3 4 5 2 1]
[0 20 40 60 80 100]

`plt()`

Matplotlib 可以將直方圖的數字表示轉換為圖形。 pyplot子模組的plt()函式將包含資料和bin陣列的陣列作為引數，並轉換為直方圖。

from matplotlib import pyplot as plt 
import numpy as np  

a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) 
plt.hist(a, bins =  [0,20,40,60,80,100]) 
plt.title("histogram") 
plt.show()

輸出如下：

Histogram Plot

NumPy - IO

ndarray物件可以儲存到磁碟檔案並從磁碟檔案載入。可用的 IO 功能有：

load()和save()函式處理 numPy 二進位制檔案（帶npy副檔名）
loadtxt()和savetxt()函式處理正常的文字檔案

NumPy 為ndarray物件引入了一個簡單的檔案格式。這個npy檔案在磁碟檔案中，儲存重建ndarray所需的資料、圖形、dtype和其他資訊，以便正確獲取陣列，即使該檔案在具有不同架構的另一臺機器上。

`numpy.save()`

numpy.save()檔案將輸入陣列儲存在具有npy副檔名的磁碟檔案中。

import numpy as np 
a = np.array([1,2,3,4,5]) 
np.save('outfile',a)

為了從outfile.npy重建陣列，請使用load()函式。

import numpy as np 
b = np.load('outfile.npy')  
print b

輸出如下：

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

save()和load()函式接受一個附加的布林引數allow_pickles。 Python 中的pickle用於在儲存到磁碟檔案或從磁碟檔案讀取之前，對物件進行序列化和反序列化。

`savetxt()`

以簡單文字檔案格式儲存和獲取陣列資料，是通過savetxt()和loadtx()函式完成的。

示例

import numpy as np 

a = np.array([1,2,3,4,5]) 
np.savetxt('out.txt',a) 
b = np.loadtxt('out.txt')  
print b

輸出如下：

[ 1.  2.  3.  4.  5.]

savetxt()和loadtxt()數接受附加的可選引數，例如頁首，頁尾和分隔符。

NumPy - 實用資源

以下資源包含有關 NumPy 的其他資訊。請使用它們獲得更多的深入知識。

NumPy 超詳細教程（1）：NumPy 陣列
2019-03-15
陣列
NumPy 超詳細教程（2）：資料型別
2019-03-18
資料型別
【轉】Python之Numpy詳細教程
2021-01-05
Python
NumPy之:NumPy簡介教程
2021-04-21
NumPy 新手教程
2023-12-20
收藏|Numpy詳細教程
2018-12-05
NumPy 超詳細教程（3）：ndarray 的內部機理及高階迭代
2019-04-01
Python Numpy基礎教程
2019-06-16
Python
清晰易懂的Numpy入門教程
2020-04-06
Python庫安裝教程之Numpy
2021-05-21
Python
Python中的Numpy入門教程
2018-06-10
Python
用js玩轉Scriptable，超簡單教程
2022-01-16
JS
TensorFlow學習（十三）：構造LSTM超長簡明教程
2018-10-18
NumPy快餐教程(2) – 多維陣列進階
2019-02-16
陣列
NumPy快餐教程(1) – 如何生成多維陣列
2019-02-16
陣列
PyThon numpy中array如何轉list？
2021-09-11
Python
Numpy學習（2）numpy向量化、numpy操作
2020-10-13
Python技術分享：numpy庫的安裝教程
2021-04-16
Python
GitHub和Git超超超詳細使用教程！
2017-10-26
Github
使用XML HTTP傳送超長XML表單資料(轉)
2007-08-12
XMLHTTP
Numpy
2024-04-09
【轉】numpy：python資料領域的功臣
2021-01-05
Python
NumPy 均勻分佈模擬及 Seaborn 視覺化教程
2024-05-30
視覺化
numpy中的numpy boolean substract,the '-' operator 錯誤
2019-02-01
Boolean
Python學習教程：Numpy系列，建立陣列的三大絕招
2019-07-29
Python陣列
Redis安裝教程（超詳細）
2022-05-05
Redis
超詳細kafka教程來啦
2021-09-05
Kafka
Java™ 教程（Object作為超類）
2019-01-19
JavaObject
NumPy常用操作
2021-06-06
Numpy基礎
2020-12-11
NumPy Tips
2018-04-12
Numpy 矩陣
2017-05-04
矩陣
Numpy 入門
2018-01-02
numpy 基礎入門 - 30分鐘學會numpy
2018-04-03
31_Pandas.DataFrame，Series和NumPy陣列ndarray相互轉換
2020-12-20
陣列
DJL 之 Java 玩轉多維陣列，就像 NumPy 一樣
2020-09-03
Java陣列
HTML教程(轉)
2007-08-12
HTML
numpy學習筆記 – numpy陣列的常見用法
2018-08-26
筆記陣列

【轉】NumPy 教程（超長）

NumPy - 簡介

NumPy 操作

NumPy – MatLab 的替代之一

NumPy - 環境

線上嘗試

Windows

Linux

對於 Ubuntu

對於 Fedora

從原始碼構建

NumPy - Ndarray 物件

示例 1

示例 2

示例 3

示例 4

NumPy - 資料型別

資料型別物件 (dtype)

示例 1

示例 2

示例 3

示例 4

示例 5

示例 6

示例 7

示例 8

NumPy - 陣列屬性

ndarray.shape

示例 1

示例 2

示例 3

ndarray.ndim

示例 1

示例 2

numpy.itemsize

示例 1

示例 2

numpy.flags

示例

NumPy - 陣列建立例程

numpy.empty

示例

numpy.zeros

示例 1

示例 2

示例 3

numpy.ones

示例 1

示例 2

NumPy - 來自現有資料的陣列

numpy.asarray

示例 1

示例 2

示例 3

示例 4

numpy.frombuffer

示例

numpy.fromiter

示例 1

示例 2

NumPy - 來自數值範圍的陣列

numpy.arange

示例 1

示例 2

示例 3

numpy.linspace

示例 1

示例 2

示例 3

numpy.logspace

示例 1

示例 2

NumPy - 切片和索引

示例 1

示例 2

示例 3

示例 4

示例 5

示例 6

示例 7

資料型別物件 (`dtype`)

`ndarray.shape`

`ndarray.ndim`

`numpy.itemsize`

`numpy.flags`

`numpy.empty`

`numpy.zeros`

`numpy.ones`

`numpy.asarray`

`numpy.frombuffer`

`numpy.fromiter`

`numpy.arange`

`numpy.linspace`

`numpy.logspace`

`numpy.reshape`

`numpy.ndarray.flat`

`numpy.ndarray.flatten`

`numpy.ravel`

`numpy.transpose`

`numpy.ndarray.T`

`numpy.rollaxis`

`numpy.swapaxes`

`broadcast`

`numpy.broadcast_to`

`numpy.expand_dims`

`numpy.squeeze`

`numpy.concatenate`

`numpy.stack`

`numpy.hstack`

`numpy.vstack`

`numpy.split`

`numpy.hsplit`

`numpy.vsplit`

`numpy.resize`

`numpy.append`

`numpy.insert`

`numpy.delete`

`numpy.unique`

`bitwise_and`

`bitwise_or`

`invert`

`left_shift`

`right_shift`

`numpy.char.add()`

`numpy.char.multiply()`

`numpy.char.center()`

`numpy.char.capitalize()`

`numpy.char.title()`

`numpy.char.lower()`

`numpy.char.upper()`