來源：NumPy Tutorial - TutorialsPoint

譯者：飛龍

協(xié)議：CC BY-NC-SA 4.0

• 在線閱讀
• PDF格式
• EPUB格式
• MOBI格式
• 代碼倉庫

NumPy - 簡介

NumPy 是一個 Python 包。 它代表 “Numeric Python”邓夕。 它是一個由多維數(shù)組對象和用于處理數(shù)組的例程集合組成的庫刘莹。

Numeric，即 NumPy 的前身焚刚，是由 Jim Hugunin 開發(fā)的点弯。 也開發(fā)了另一個包 Numarray ，它擁有一些額外的功能矿咕。 2005年抢肛，Travis Oliphant 通過將 Numarray 的功能集成到 Numeric 包中來創(chuàng)建 NumPy 包。 這個開源項目有很多貢獻者碳柱。

NumPy 操作

使用NumPy雌团，開發(fā)人員可以執(zhí)行以下操作：

• 數(shù)組的算數(shù)和邏輯運算。

• 傅立葉變換和用于圖形操作的例程士聪。

• 與線性代數(shù)有關的操作锦援。 NumPy 擁有線性代數(shù)和隨機數(shù)生成的內(nèi)置函數(shù)。

NumPy – MatLab 的替代之一

NumPy 通常與 SciPy（Scientific Python）和 Matplotlib（繪圖庫）一起使用剥悟。 這種組合廣泛用于替代 MatLab灵寺，是一個流行的技術計算平臺曼库。 但是，Python 作為 MatLab 的替代方案略板，現(xiàn)在被視為一種更加現(xiàn)代和完整的編程語言毁枯。

NumPy 是開源的，這是它的一個額外的優(yōu)勢叮称。

NumPy - 環(huán)境

在線嘗試

我們已經(jīng)在線設置了 NumPy 編程環(huán)境种玛，以便在線編譯和執(zhí)行所有可用的示例。 它向你提供了信心瓤檐，并使您能夠使用不同的選項驗證程序赂韵， 隨意修改任何示例并在線執(zhí)行。

使用我們的在線編譯器嘗試一下示例挠蛉，它位于 CodingGround

import numpy as np 
a =  'hello world'  
print a

對于本教程中給出的大多數(shù)示例祭示，你會在我們的網(wǎng)站代碼部分的右上角找到一個Try it選項，這會把你帶到在線編譯器谴古。 所以快來使用它质涛，享受你的學習吧。

標準的 Python 發(fā)行版不會與 NumPy 模塊捆綁在一起掰担。 一個輕量級的替代方法是使用流行的 Python 包安裝程序 pip 來安裝 NumPy汇陆。

pip install numpy

啟用 NumPy 的最佳方法是使用特定于您的操作系統(tǒng)的可安裝的二進制包。 這些二進制包含完整的 SciPy 技術棧（包括 NumPy带饱，SciPy瞬测，matplotlib，IPython纠炮，SymPy 以及 Python 核心自帶的其它包）。

Windows

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

Canopy (www.enthought.com/products/canopy/) 是可用的免費和商業(yè)發(fā)行版恢口，帶有完整的 SciPy 技術棧，可用于 Windows, Linux and Mac穷躁。

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

Linux

Linux 發(fā)行版的相應軟件包管理器可用于安裝一個或多個 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 維數(shù)組類型语婴。 它描述相同類型的元素集合描孟。 可以使用基于零的索引訪問集合中的項目。

ndarray中的每個元素在內(nèi)存中使用相同大小的塊砰左。 ndarray中的每個元素是數(shù)據(jù)類型對象的對象（稱為 dtype）匿醒。

從ndarray對象提取的任何元素（通過切片）由一個數(shù)組標量類型的 Python 對象表示。 下圖顯示了ndarray菜职，數(shù)據(jù)類型對象（dtype）和數(shù)組標量類型之間的關系青抛。

Ndarray

ndarray類的實例可以通過本教程后面描述的不同的數(shù)組創(chuàng)建例程來構造。 基本的ndarray是使用 NumPy 中的數(shù)組函數(shù)創(chuàng)建的酬核，如下所示：

numpy.array 

它從任何暴露數(shù)組接口的對象蜜另，或從返回數(shù)組的任何方法創(chuàng)建一個ndarray。

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

上面的構造器接受以下參數(shù)：

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

示例 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 參數(shù)  
import numpy as np 
a = np.array([1,  2,  3], dtype = complex)  
print a

輸出如下：

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

**ndarray ** 對象由計算機內(nèi)存中的一維連續(xù)區(qū)域組成隙券，帶有將每個元素映射到內(nèi)存塊中某個位置的索引方案男应。 內(nèi)存塊以按行（C 風格）或按列（FORTRAN 或 MatLab 風格）的方式保存元素。

NumPy - 數(shù)據(jù)類型

NumPy 支持比 Python 更多種類的數(shù)值類型娱仔。 下表顯示了 NumPy 中定義的不同標量數(shù)據(jù)類型沐飘。

NumPy 數(shù)字類型是dtype（數(shù)據(jù)類型）對象的實例，每個對象具有唯一的特征竹握。 這些類型可以是np.bool_画株，np.float32等。

數(shù)據(jù)類型對象 (dtype)

數(shù)據(jù)類型對象描述了對應于數(shù)組的固定內(nèi)存塊的解釋啦辐，取決于以下方面：

• 數(shù)據(jù)類型（整數(shù)谓传、浮點或者 Python 對象）

• 數(shù)據(jù)大小

• 字節(jié)序（小端或大端）

• 在結構化類型的情況下，字段的名稱芹关，每個字段的數(shù)據(jù)類型，和每個字段占用的內(nèi)存塊部分侥衬。

• 如果數(shù)據(jù)類型是子序列诗祸，它的形狀和數(shù)據(jù)類型。

字節(jié)順序取決于數(shù)據(jù)類型的前綴<或>轴总。 <意味著編碼是小端（最小有效字節(jié)存儲在最小地址中）直颅。 >意味著編碼是大端（最大有效字節(jié)存儲在最小地址中）。

dtype可由一下語法構造：

numpy.dtype(object, align, copy)

參數(shù)為：

• Object：被轉換為數(shù)據(jù)類型的對象怀樟。

• Align：如果為true功偿，則向字段添加間隔，使其類似 C 的結構體漂佩。

• Copy ? 生成dtype對象的新副本，如果為flase罪塔，結果是內(nèi)建數(shù)據(jù)類型對象的引用投蝉。

示例 1

# 使用數(shù)組標量類型  
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

下面的例子展示了結構化數(shù)據(jù)類型的使用。 這里聲明了字段名稱和相應的標量數(shù)據(jù)類型熟尉。

示例 4

# 首先創(chuàng)建結構化數(shù)據(jù)類型归露。  
import numpy as np 
dt = np.dtype([('age',np.int8)])  
print dt 

輸出如下：

[('age', 'i1')] 

示例 5

# 現(xiàn)在將其應用于 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 列的內(nèi)容  
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 的結構化數(shù)據(jù)類型，其中包含字符串字段name斤儿，整數(shù)字段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)]

每個內(nèi)建類型都有一個唯一定義它的字符代碼：

• 'b'：布爾值

• 'i'：符號整數(shù)

• 'u'：無符號整數(shù)

• 'f'：浮點

• 'c'：復數(shù)浮點

• 'm'：時間間隔

• 'M'：日期時間

• 'O'：Python 對象

• 'S', 'a'：字節(jié)串

• 'U'：Unicode

• 'V'：原始數(shù)據(jù)（void）

NumPy - 數(shù)組屬性

這一章中往果，我們會討論 NumPy 的多種數(shù)組屬性疆液。

ndarray.shape

這一數(shù)組屬性返回一個包含數(shù)組維度的元組，它也可以用于調(diào)整數(shù)組大小陕贮。

示例 1

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

輸出如下：

(2, 3)

示例 2

# 這會調(diào)整數(shù)組大小  
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函數(shù)來調(diào)整數(shù)組大小堕油。

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

這一數(shù)組屬性返回數(shù)組的維數(shù)。

示例 1

# 等間隔數(shù)字的數(shù)組  
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

# 一維數(shù)組  
import numpy as np 
a = np.arange(24) a.ndim 
# 現(xiàn)在調(diào)整其大小
b = a.reshape(2,4,3)  
print b 
# b 現(xiàn)在擁有三個維度

輸出如下：

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

這一數(shù)組屬性返回數(shù)組中每個元素的字節(jié)單位長度肮之。

示例 1

# 數(shù)組的 dtype 為 int8（一個字節(jié)）  
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.int8)  
print x.itemsize

輸出如下：

1

示例 2

# 數(shù)組的 dtype 現(xiàn)在為 float32（四個字節(jié)）  
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.float32)  
print x.itemsize

輸出如下：

4

numpy.flags

ndarray對象擁有以下屬性掉缺。這個函數(shù)返回了它們的當前值。

示例

下面的例子展示當前的標志凯傲。

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 - 數(shù)組創(chuàng)建例程

新的ndarray對象可以通過任何下列數(shù)組創(chuàng)建例程或使用低級ndarray構造函數(shù)構造犬辰。

numpy.empty

它創(chuàng)建指定形狀和dtype的未初始化數(shù)組。 它使用以下構造函數(shù)：

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

構造器接受下列參數(shù)：

示例

下面的代碼展示空數(shù)組的例子：

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

輸出如下：

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

注意：數(shù)組元素為隨機值诫欠，因為它們未初始化涵卵。

numpy.zeros

返回特定大小，以 0 填充的新數(shù)組荒叼。

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

構造器接受下列參數(shù)：

示例 1

# 含有 5 個 0 的數(shù)組坏晦，默認類型為 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 填充的新數(shù)組。

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

構造器接受下列參數(shù)：

示例 1

# 含有 5 個 1 的數(shù)組仓蛆，默認類型為 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 - 來自現(xiàn)有數(shù)據(jù)的數(shù)組

這一章中，我們會討論如何從現(xiàn)有數(shù)據(jù)創(chuàng)建數(shù)組多律。

numpy.asarray

此函數(shù)類似于numpy.array痴突，除了它有較少的參數(shù)。 這個例程對于將 Python 序列轉換為ndarray非常有用狼荞。

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

構造器接受下列參數(shù)：

下面的例子展示了如何使用asarray函數(shù)：

示例 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

此函數(shù)將緩沖區(qū)解釋為一維數(shù)組。 暴露緩沖區(qū)接口的任何對象都用作參數(shù)來返回ndarray一死。

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

構造器接受下列參數(shù)：

示例

下面的例子展示了frombuffer函數(shù)的用法。

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

此函數(shù)從任何可迭代對象構建一個ndarray對象伪煤，返回一個新的一維數(shù)組加袋。

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

構造器接受下列參數(shù)：

以下示例展示了如何使用內(nèi)置的range()函數(shù)返回列表對象职烧。 此列表的迭代器用于形成ndarray對象。

示例 1

# 使用 range 函數(shù)創(chuàng)建列表對象  
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)  
# 使用迭代器創(chuàng)建 ndarray 
x = np.fromiter(it, dtype =  float)  
print x

輸出如下：

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

NumPy - 來自數(shù)值范圍的數(shù)組

這一章中防泵，我們會學到如何從數(shù)值范圍創(chuàng)建數(shù)組蚀之。

numpy.arange

這個函數(shù)返回ndarray對象，包含給定范圍內(nèi)的等間隔值捷泞。

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

構造器接受下列參數(shù)：

下面的例子展示了如何使用該函數(shù)：

示例 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

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

輸出如下：

[10  12  14  16  18]

numpy.linspace

此函數(shù)類似于arange()函數(shù)骡湖。 在此函數(shù)中贱纠，指定了范圍之間的均勻間隔數(shù)量，而不是步長响蕴。 此函數(shù)的用法如下谆焊。

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

構造器接受下列參數(shù)：

下面的例子展示了linspace函數(shù)的用法。

示例 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

此函數(shù)返回一個ndarray對象肥缔，其中包含在對數(shù)刻度上均勻分布的數(shù)字莲兢。 刻度的開始和結束端點是某個底數(shù)的冪，通常為 10续膳。

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

logspace函數(shù)的輸出由以下參數(shù)決定：

下面的例子展示了logspace函數(shù)的用法社付。

示例 1

import numpy as np
# 默認底數(shù)是 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

# 將對數(shù)空間的底數(shù)設置為 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對象的內(nèi)容可以通過索引或切片來訪問和修改承疲，就像 Python 的內(nèi)置容器對象一樣。

如前所述瘦穆，ndarray對象中的元素遵循基于零的索引纪隙。 有三種可用的索引方法類型： 字段訪問，基本切片和高級索引扛或。

基本切片是 Python 中基本切片概念到 n 維的擴展绵咱。 通過將start，stop和step參數(shù)提供給內(nèi)置的slice函數(shù)來構造一個 Python slice對象熙兔。 此slice對象被傳遞給數(shù)組來提取數(shù)組的一部分悲伶。

示例 1

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

輸出如下：

[2  4  6]

在上面的例子中，ndarray對象由arange()函數(shù)創(chuàng)建住涉。 然后麸锉，分別用起始，終止和步長值2舆声，7和2定義切片對象花沉。 當這個切片對象傳遞給ndarray時柳爽，會對它的一部分進行切片，從索引2到7碱屁，步長為2磷脯。

通過將由冒號分隔的切片參數(shù)（start:stop:step）直接提供給ndarray對象，也可以獲得相同的結果娩脾。

示例 2

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

輸出如下：

[2  4  6]

如果只輸入一個參數(shù)赵誓，則將返回與索引對應的單個項目。 如果使用a:柿赊，則從該索引向后的所有項目將被提取俩功。 如果使用兩個參數(shù)（以:分隔），則對兩個索引（不包括停止索引）之間的元素以默認步驟進行切片碰声。

示例 3

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

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

輸出如下：

5

示例 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  '現(xiàn)在我們從索引 a[1:] 開始對數(shù)組切片'  
print a[1:]

輸出如下：

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

現(xiàn)在我們從索引 a[1:] 開始對數(shù)組切片
[[3 4 5]
 [4 5 6]]

切片還可以包括省略號（...），來使選擇元組的長度與數(shù)組的維度相同胰挑。 如果在行位置使用省略號万牺，它將返回包含行中元素的ndarray。

示例 7

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

輸出如下：

我們的數(shù)組是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]

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

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

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

NumPy - 高級索引

如果一個ndarray是非元組序列洽腺，數(shù)據(jù)類型為整數(shù)或布爾值的ndarray脚粟，或者至少一個元素為序列對象的元組，我們就能夠用它來索引ndarray蘸朋。高級索引始終返回數(shù)據(jù)的副本核无。 與此相反，切片只提供了一個視圖藕坯。

有兩種類型的高級索引：整數(shù)和布爾值团南。

整數(shù)索引

這種機制有助于基于 N 維索引來獲取數(shù)組中任意元素。 每個整數(shù)數(shù)組表示該維度的下標值炼彪。 當索引的元素個數(shù)就是目標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]

該結果包括數(shù)組中(0,0)冗疮，(1,1)和(2,0)位置處的元素。

下面的示例獲取了 4X3 數(shù)組中的每個角處的元素檩帐。 行索引是[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  '我們的數(shù)組是：'  
print x 
print  '\n' 
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print  '這個數(shù)組的每個角處的元素是：'  
print y

輸出如下：

我們的數(shù)組是：                                                                 
[[ 0  1  2]                                                                   
 [ 3  4  5]                                                                   
 [ 6  7  8]                                                                   
 [ 9 10 11]]

這個數(shù)組的每個角處的元素是：                                      
[[ 0  2]                                                                      
 [ 9 11]] 

返回的結果是包含每個角元素的ndarray對象碘梢。

高級和基本索引可以通過使用切片:或省略號...與索引數(shù)組組合雷客。 以下示例使用slice作為列索引和高級索引掐禁。 當切片用于兩者時彼绷，結果是相同的。 但高級索引會導致復制，并且可能有不同的內(nèi)存布局。

示例 3

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print  '我們的數(shù)組是：'  
print x 
print  '\n'  
# 切片
z = x[1:4,1:3]  
print  '切片之后阱表，我們的數(shù)組變?yōu)椋?  
print z 
print  '\n'  
# 對列使用高級索引 
y = x[1:4,[1,2]] 
print  '對列使用高級索引來切片：'  
print y

輸出如下：

我們的數(shù)組是：
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8]
 [ 9 10 11]]

切片之后，我們的數(shù)組變?yōu)椋?[[ 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  '我們的數(shù)組是：'  
print x 
print  '\n'  
# 現(xiàn)在我們會打印出大于 5 的元素  
print  '大于 5 的元素是：'  
print x[x >  5]

輸出如下：

我們的數(shù)組是：
[[ 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

以下示例顯示如何從數(shù)組中過濾掉非復數(shù)元素。

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 在算術運算期間處理不同形狀的數(shù)組的能力。 對數(shù)組的算術運算通常在相應的元素上進行。 如果兩個陣列具有完全相同的形狀噪馏，則這些操作被無縫執(zhí)行麦到。

示例 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]

如果兩個數(shù)組的維數(shù)不相同，則元素到元素的操作是不可能的欠肾。 然而瓶颠，在 NumPy 中仍然可以對形狀不相似的數(shù)組進行操作，因為它擁有廣播功能刺桃。 較小的數(shù)組會廣播到較大數(shù)組的大小粹淋，以便使它們的形狀可兼容。

如果滿足以下規(guī)則瑟慈，可以進行廣播：

• ndim較小的數(shù)組會在前面追加一個長度為 1 的維度桃移。

• 輸出數(shù)組的每個維度的大小是輸入數(shù)組該維度大小的最大值。

• 如果輸入在每個維度中的大小與輸出大小匹配封豪，或其值正好為 1谴轮，則在計算中可它炒瘟。

• 如果輸入的某個維度大小為 1吹埠，則該維度中的第一個數(shù)據(jù)元素將用于該維度的所有計算。

如果上述規(guī)則產(chǎn)生有效結果疮装，并且滿足以下條件之一缘琅，那么數(shù)組被稱為可廣播的。

• 數(shù)組擁有相同形狀廓推。

• 數(shù)組擁有相同的維數(shù)刷袍，每個維度擁有相同長度，或者長度為 1樊展。

• 數(shù)組擁有極少的維度呻纹，可以在其前面追加長度為 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  '第一個數(shù)組：'  
print a 
print  '\n'  
print  '第二個數(shù)組：'  
print b 
print  '\n'  
print  '第一個數(shù)組加第二個數(shù)組：'  
print a + b

輸出如下：

第一個數(shù)組：
[[ 0. 0. 0.]
 [ 10. 10. 10.]
 [ 20. 20. 20.]
 [ 30. 30. 30.]]

第二個數(shù)組：
[ 1. 2. 3.]

第一個數(shù)組加第二個數(shù)組：
[[ 1. 2. 3.]
 [ 11. 12. 13.]
 [ 21. 22. 23.]
 [ 31. 32. 33.]]

下面的圖片展示了數(shù)組b如何通過廣播來與數(shù)組a兼容。

array

NumPy - 數(shù)組上的迭代

NumPy 包包含一個迭代器對象numpy.nditer涝婉。 它是一個有效的多維迭代器對象哥力，可以用于在數(shù)組上進行迭代。 數(shù)組的每個元素可使用 Python 的標準Iterator接口來訪問。

讓我們使用arange()函數(shù)創(chuàng)建一個 3X4 數(shù)組吩跋，并使用nditer對它進行迭代寞射。

示例 1

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

輸出如下：

原始數(shù)組是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

修改后的數(shù)組是：
0 5 10 15 20 25 30 35 40 45 50 55

示例 2

迭代的順序匹配數(shù)組的內(nèi)容布局，而不考慮特定的排序锌钮。 這可以通過迭代上述數(shù)組的轉置來看到桥温。

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

輸出如下：

原始數(shù)組是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

原始數(shù)組的轉置是：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

修改后的數(shù)組是：
0 5 10 15 20 25 30 35 40 45 50 55

迭代順序

如果相同元素使用 F 風格順序存儲，則迭代器選擇以更有效的方式對數(shù)組進行迭代轧粟。

示例 1

import numpy as np
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始數(shù)組是：'  
print a print  '\n'  
print  '原始數(shù)組的轉置是：' 
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,

輸出如下：

原始數(shù)組是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

原始數(shù)組的轉置是：
[[ 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  '原始數(shù)組是：'  
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,

輸出如下：

原始數(shù)組是：
[[ 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

修改數(shù)組的值

nditer對象有另一個可選參數(shù)op_flags。 其默認值為只讀兰吟，但可以設置為讀寫或只寫模式通惫。 這將允許使用此迭代器修改數(shù)組元素。

示例

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

輸出如下：

原始數(shù)組是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

修改后的數(shù)組是：
[[ 0 10 20 30]
 [ 40 50 60 70]
 [ 80 90 100 110]]

外部循環(huán)

nditer類的構造器擁有flags參數(shù)混蔼，它可以接受下列值：

示例

在下面的示例中，迭代器遍歷對應于每列的一維數(shù)組惭嚣。

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

輸出如下：

原始數(shù)組是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

修改后的數(shù)組是：
[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]

廣播迭代

如果兩個數(shù)組是可廣播的遵湖，nditer組合對象能夠同時迭代它們。 假設數(shù)組a具有維度 3X4晚吞，并且存在維度為 1X4 的另一個數(shù)組b延旧，則使用以下類型的迭代器（數(shù)組b被廣播到a的大小）槽地。

示例

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

輸出如下：

第一個數(shù)組：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

第二個數(shù)組：
[1 2 3 4]

修改后的數(shù)組是：
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 - 數(shù)組操作

NumPy包中有幾個例程用于處理ndarray對象中的元素迁沫。 它們可以分為以下類型：

修改形狀

numpy.reshape

這個函數(shù)在不改變數(shù)據(jù)的條件下修改形狀，它接受如下參數(shù)：

numpy.reshape(arr, newshape, order')

其中：

• arr：要修改形狀的數(shù)組
• newshape：整數(shù)或者整數(shù)數(shù)組捌蚊，新的形狀應當兼容原有形狀
• order：'C'為 C 風格順序集畅，'F'為 F 風格順序，'A'為保留原順序缅糟。

例子

import numpy as np
a = np.arange(8)
print '原始數(shù)組：'
print a
print '\n'

b = a.reshape(4,2)
print '修改后的數(shù)組：'
print b

輸出如下：

原始數(shù)組：
[0 1 2 3 4 5 6 7]

修改后的數(shù)組：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

numpy.ndarray.flat

該函數(shù)返回數(shù)組上的一維迭代器挺智，行為類似 Python 內(nèi)建的迭代器。

例子

import numpy as np 
a = np.arange(8).reshape(2,4) 
print '原始數(shù)組：' 
print a 
print '\n' 

print '調(diào)用 flat 函數(shù)之后：' 
# 返回展開數(shù)組中的下標的對應元素 
print a.flat[5]

輸出如下：

原始數(shù)組：
[[0 1 2 3]
 [4 5 6 7]]

調(diào)用 flat 函數(shù)之后：
5

numpy.ndarray.flatten

該函數(shù)返回折疊為一維的數(shù)組副本窗宦，函數(shù)接受下列參數(shù)：

ndarray.flatten(order)

其中：

• order：'C' -- 按行赦颇，'F' -- 按列，'A' -- 原順序赴涵，'k' -- 元素在內(nèi)存中的出現(xiàn)順序媒怯。

例子

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

print '原數(shù)組：' 
print a 
print '\n'  
# default is column-major 

print '展開的數(shù)組：' 
print a.flatten() 
print '\n'  

print '以 F 風格順序展開的數(shù)組：' 
print a.flatten(order = 'F')

輸出如下：

原數(shù)組：
[[0 1 2 3]
 [4 5 6 7]]

展開的數(shù)組：
[0 1 2 3 4 5 6 7]

以 F 風格順序展開的數(shù)組：
[0 4 1 5 2 6 3 7]

numpy.ravel

這個函數(shù)返回展開的一維數(shù)組，并且按需生成副本句占。返回的數(shù)組和輸入數(shù)組擁有相同數(shù)據(jù)類型沪摄。這個函數(shù)接受兩個參數(shù)。

numpy.ravel(a, order)

構造器接受下列參數(shù)：

• order：'C' -- 按行，'F' -- 按列杨拐，'A' -- 原順序祈餐，'k' -- 元素在內(nèi)存中的出現(xiàn)順序。

例子

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

print '原數(shù)組：' 
print a 
print '\n'  

print '調(diào)用 ravel 函數(shù)之后：' 
print a.ravel()  
print '\n' 

print '以 F 風格順序調(diào)用 ravel 函數(shù)之后：' 
print a.ravel(order = 'F')

原數(shù)組：
[[0 1 2 3]
 [4 5 6 7]]

調(diào)用 ravel 函數(shù)之后：
[0 1 2 3 4 5 6 7]

以 F 風格順序調(diào)用 ravel 函數(shù)之后：
[0 4 1 5 2 6 3 7]

翻轉操作

numpy.transpose

這個函數(shù)翻轉給定數(shù)組的維度哄陶。如果可能的話它會返回一個視圖帆阳。函數(shù)接受下列參數(shù)：

numpy.transpose(arr, axes)

其中：

• arr：要轉置的數(shù)組
• axes：整數(shù)的列表，對應維度屋吨，通常所有維度都會翻轉蜒谤。

例子

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

print '原數(shù)組：' 
print a  
print '\n' 

print '轉置數(shù)組：' 
print np.transpose(a)

輸出如下：

原數(shù)組：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

轉置數(shù)組：
[[ 0 4 8]
 [ 1 5 9]
 [ 2 6 10]
 [ 3 7 11]]

numpy.ndarray.T

該函數(shù)屬于ndarray類，行為類似于numpy.transpose至扰。

例子

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

print '原數(shù)組：' 
print a 
print '\n'  

print '轉置數(shù)組：' 
print a.T

輸出如下：

原數(shù)組：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

轉置數(shù)組：
[[ 0 4 8]
 [ 1 5 9]
 [ 2 6 10]
 [ 3 7 11]]

numpy.rollaxis

該函數(shù)向后滾動特定的軸鳍徽，直到一個特定位置。這個函數(shù)接受三個參數(shù)：

numpy.rollaxis(arr, axis, start)

其中：

• arr：輸入數(shù)組
• axis：要向后滾動的軸敢课，其它軸的相對位置不會改變
• start：默認為零阶祭，表示完整的滾動。會滾動到特定位置直秆。

例子

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

print '原數(shù)組：' 
print a 
print '\n'
# 將軸 2 滾動到軸 0（寬度到深度）

print '調(diào)用 rollaxis 函數(shù)：' 
print np.rollaxis(a,2)  
# 將軸 0 滾動到軸 1：（寬度到高度）
print '\n' 

print '調(diào)用 rollaxis 函數(shù)：' 
print np.rollaxis(a,2,1)

輸出如下：

原數(shù)組：
[[[0 1]
 [2 3]]
 [[4 5]
 [6 7]]]

調(diào)用 rollaxis 函數(shù)：
[[[0 2]
 [4 6]]
 [[1 3]
 [5 7]]]

調(diào)用 rollaxis 函數(shù)：
[[[0 2]
 [1 3]]
 [[4 6]
 [5 7]]]

numpy.swapaxes

該函數(shù)交換數(shù)組的兩個軸濒募。對于 1.10 之前的 NumPy 版本，會返回交換后數(shù)組的試圖圾结。這個函數(shù)接受下列參數(shù)：

numpy.swapaxes(arr, axis1, axis2)

• arr：要交換其軸的輸入數(shù)組
• axis1：對應第一個軸的整數(shù)
• axis2：對應第二個軸的整數(shù)

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

print '原數(shù)組：'
print a 
print '\n'  
# 現(xiàn)在交換軸 0（深度方向）到軸 2（寬度方向）

print '調(diào)用 swapaxes 函數(shù)后的數(shù)組：' 
print np.swapaxes(a, 2, 0)

輸出如下：

原數(shù)組：
[[[0 1]
 [2 3]]

 [[4 5]
  [6 7]]]

調(diào)用 swapaxes 函數(shù)后的數(shù)組：
[[[0 4]
 [2 6]]
 
 [[1 5]
  [3 7]]]

修改維度

broadcast

如前所述瑰剃，NumPy 已經(jīng)內(nèi)置了對廣播的支持。 此功能模仿廣播機制筝野。 它返回一個對象宁赤，該對象封裝了將一個數(shù)組廣播到另一個數(shù)組的結果晾腔。

該函數(shù)使用兩個數(shù)組作為輸入?yún)?shù)酪劫。 下面的例子說明了它的用法扼仲。

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 '調(diào)用 flat 函數(shù)：' 
print c 
print '\n'  
# 獲得了和 NumPy 內(nèi)建的廣播支持相同的結果

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

輸出如下：

對 y 廣播 x：
1 4
1 5

廣播對象的形狀：
(3, 3)

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

調(diào)用 flat 函數(shù)：
[[ 5. 6. 7.]
 [ 6. 7. 8.]
 [ 7. 8. 9.]]

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

numpy.broadcast_to

此函數(shù)將數(shù)組廣播到新形狀途蒋。 它在原始數(shù)組上返回只讀視圖。 它通常不連續(xù)馋记。 如果新形狀不符合 NumPy 的廣播規(guī)則号坡，該函數(shù)可能會拋出ValueError。

注意 - 此功能可用于 1.10.0 及以后的版本梯醒。

該函數(shù)接受以下參數(shù)宽堆。

numpy.broadcast_to(array, shape, subok)

例子

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

print '原數(shù)組：' 
print a 
print '\n'  

print '調(diào)用 broadcast_to 函數(shù)之后：' 
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

函數(shù)通過在指定位置插入新的軸來擴展數(shù)組形狀。該函數(shù)需要兩個參數(shù)：

numpy.expand_dims(arr, axis)

其中：

• arr：輸入數(shù)組
• axis：新軸插入的位置

例子

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

print '數(shù)組 x：' 
print x 
print '\n'  
y = np.expand_dims(x, axis = 0) 

print '數(shù)組 y：' 
print y 
print '\n'

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

print '在位置 1 插入軸之后的數(shù)組 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

輸出如下：

數(shù)組 x：
[[1 2]
 [3 4]]

數(shù)組 y：
[[[1 2]
 [3 4]]]

數(shù)組 x 和 y 的形狀：
(2, 2) (1, 2, 2)

在位置 1 插入軸之后的數(shù)組 y：
[[[1 2]]
 [[3 4]]]

x.shape 和 y.shape：
2 3

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

numpy.squeeze

函數(shù)從給定數(shù)組的形狀中刪除一維條目茸习。 此函數(shù)需要兩個參數(shù)畜隶。

numpy.squeeze(arr, axis)

其中：

• arr：輸入數(shù)組
• axis：整數(shù)或整數(shù)元組，用于選擇形狀中單一維度條目的子集

例子

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

print '數(shù)組 x：' 
print x 
print '\n'  
y = np.squeeze(x) 

print '數(shù)組 y：' 
print y 
print '\n'  

print '數(shù)組 x 和 y 的形狀：' 
print x.shape, y.shape

輸出如下：

數(shù)組 x：
[[[0 1 2]
 [3 4 5]
 [6 7 8]]]

數(shù)組 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]

數(shù)組 x 和 y 的形狀：
(1, 3, 3) (3, 3)

數(shù)組的連接

numpy.concatenate

數(shù)組的連接是指連接。 此函數(shù)用于沿指定軸連接相同形狀的兩個或多個數(shù)組籽慢。 該函數(shù)接受以下參數(shù)浸遗。

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

其中：

• a1, a2, ...：相同類型的數(shù)組序列
• axis：沿著它連接數(shù)組的軸，默認為 0

例子

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

print '第一個數(shù)組：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 

print '第二個數(shù)組：' 
print b 
print '\n'  
# 兩個數(shù)組的維度相同 

print '沿軸 0 連接兩個數(shù)組：' 
print np.concatenate((a,b)) 
print '\n'  

print '沿軸 1 連接兩個數(shù)組：' 
print np.concatenate((a,b),axis = 1)

輸出如下：

第一個數(shù)組：
[[1 2]
 [3 4]]

第二個數(shù)組：
[[5 6]
 [7 8]]

沿軸 0 連接兩個數(shù)組：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

沿軸 1 連接兩個數(shù)組：
[[1 2 5 6]
 [3 4 7 8]]

numpy.stack

此函數(shù)沿新軸連接數(shù)組序列箱亿。 此功能添加自 NumPy 版本 1.10.0跛锌。 需要提供以下參數(shù)。

numpy.stack(arrays, axis)

其中：

• arrays：相同形狀的數(shù)組序列
• axis：返回數(shù)組中的軸届惋，輸入數(shù)組沿著它來堆疊

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

print '第一個數(shù)組：' 
print a 
print '\n'
b = np.array([[5,6],[7,8]]) 

print '第二個數(shù)組：' 
print b 
print '\n'  

print '沿軸 0 堆疊兩個數(shù)組：' 
print np.stack((a,b),0) 
print '\n'  

print '沿軸 1 堆疊兩個數(shù)組：' 
print np.stack((a,b),1)

輸出如下：

第一個數(shù)組：
[[1 2]
 [3 4]]

第二個數(shù)組：
[[5 6]
 [7 8]]

沿軸 0 堆疊兩個數(shù)組：
[[[1 2]
 [3 4]]
 [[5 6]
 [7 8]]]

沿軸 1 堆疊兩個數(shù)組：
[[[1 2]
 [5 6]]
 [[3 4]
 [7 8]]]

numpy.hstack

numpy.stack函數(shù)的變體髓帽，通過堆疊來生成水平的單個數(shù)組。

例子

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

print '第一個數(shù)組：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 

print '第二個數(shù)組：' 
print b 
print '\n'  

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

輸出如下：

第一個數(shù)組：
[[1 2]
 [3 4]]

第二個數(shù)組：
[[5 6]
 [7 8]]

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

numpy.vstack

numpy.stack函數(shù)的變體脑豹，通過堆疊來生成豎直的單個數(shù)組郑藏。

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

print '第一個數(shù)組：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 

print '第二個數(shù)組：' 
print b 
print '\n'

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

輸出如下：

第一個數(shù)組：
[[1 2]
 [3 4]]

第二個數(shù)組：
[[5 6]
 [7 8]]

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

數(shù)組分割

numpy.split

該函數(shù)沿特定的軸將數(shù)組分割為子數(shù)組。函數(shù)接受三個參數(shù)：

numpy.split(ary, indices_or_sections, axis)

其中：

• ary：被分割的輸入數(shù)組
• indices_or_sections：可以是整數(shù)瘩欺，表明要從輸入數(shù)組創(chuàng)建的译秦，等大小的子數(shù)組的數(shù)量。 如果此參數(shù)是一維數(shù)組击碗，則其元素表明要創(chuàng)建新子數(shù)組的點筑悴。
• axis：默認為 0

例子

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

print '第一個數(shù)組：' 
print a 
print '\n'  

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

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

輸出如下：

第一個數(shù)組：
[0 1 2 3 4 5 6 7 8]

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

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

numpy.hsplit

numpy.hsplit是split()函數(shù)的特例，其中軸為 1 表示水平分割稍途，無論輸入數(shù)組的維度是什么阁吝。

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

print '第一個數(shù)組：' 
print a 
print '\n'  

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

輸出：

第一個數(shù)組：
[[ 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()函數(shù)的特例，其中軸為 0 表示豎直分割械拍，無論輸入數(shù)組的維度是什么突勇。下面的例子使之更清楚。

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

print '第一個數(shù)組：' 
print a 
print '\n'

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

輸出如下：

第一個數(shù)組：
[[ 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]])] 

添加/刪除元素

numpy.resize

此函數(shù)返回指定大小的新數(shù)組坷虑。 如果新大小大于原始大小甲馋，則包含原始數(shù)組中的元素的重復副本。 該函數(shù)接受以下參數(shù)迄损。

numpy.resize(arr, shape)

其中：

• arr：要修改大小的輸入數(shù)組
• shape：返回數(shù)組的新形狀

例子

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

print '第一個數(shù)組：' 
print a 
print '\n'

print '第一個數(shù)組的形狀：' 
print a.shape 
print '\n'  
b = np.resize(a, (3,2)) 

print '第二個數(shù)組：' 
print b 
print '\n'  

print '第二個數(shù)組的形狀：' 
print b.shape 
print '\n'  
# 要注意 a 的第一行在 b 中重復出現(xiàn)定躏，因為尺寸變大了 

print '修改第二個數(shù)組的大小：' 
b = np.resize(a,(3,3)) 
print b

輸出如下：

第一個數(shù)組：
[[1 2 3]
 [4 5 6]]

第一個數(shù)組的形狀：
(2, 3)

第二個數(shù)組：
[[1 2]
 [3 4]
 [5 6]]

第二個數(shù)組的形狀：
(3, 2)

修改第二個數(shù)組的大星鄣小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]

numpy.append

此函數(shù)在輸入數(shù)組的末尾添加值痊远。 附加操作不是原地的，而是分配新的數(shù)組氏捞。 此外碧聪，輸入數(shù)組的維度必須匹配否則將生成ValueError。

函數(shù)接受下列函數(shù)：

numpy.append(arr, values, axis)

其中：

• arr：輸入數(shù)組
• values：要向arr添加的值液茎，比如和arr形狀相同（除了要添加的軸）
• axis：沿著它完成操作的軸逞姿。如果沒有提供辞嗡，兩個參數(shù)都會被展開。

例子

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

print '第一個數(shù)組：' 
print a 
print '\n'  

print '向數(shù)組添加元素：' 
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)

輸出如下：

第一個數(shù)組：
[[1 2 3]
 [4 5 6]]

向數(shù)組添加元素：
[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

此函數(shù)在給定索引之前滞造，沿給定軸在輸入數(shù)組中插入值欲间。 如果值的類型轉換為要插入，則它與輸入數(shù)組不同断部。 插入沒有原地的猎贴，函數(shù)會返回一個新數(shù)組。 此外蝴光，如果未提供軸她渴，則輸入數(shù)組會被展開。

insert()函數(shù)接受以下參數(shù)：

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

其中：

• arr：輸入數(shù)組
• obj：在其之前插入值的索引
• values：要插入的值
• axis：沿著它插入的軸蔑祟，如果未提供趁耗，則輸入數(shù)組會被展開

例子

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

print '第一個數(shù)組：' 
print a 
print '\n'  

print '未傳遞 Axis 參數(shù)。 在插入之前輸入數(shù)組會被展開疆虚。' 
print np.insert(a,3,[11,12]) 
print '\n'  
print '傳遞了 Axis 參數(shù)苛败。 會廣播值數(shù)組來配輸入數(shù)組。' 

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

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

numpy.delete

此函數(shù)返回從輸入數(shù)組中刪除指定子數(shù)組的新數(shù)組径簿。 與insert()函數(shù)的情況一樣罢屈，如果未提供軸參數(shù)，則輸入數(shù)組將展開篇亭。 該函數(shù)接受以下參數(shù)：

Numpy.delete(arr, obj, axis)

其中：

• arr：輸入數(shù)組
• obj：可以被切片缠捌，整數(shù)或者整數(shù)數(shù)組，表明要從輸入數(shù)組刪除的子數(shù)組
• axis：沿著它刪除給定子數(shù)組的軸译蒂，如果未提供曼月，則輸入數(shù)組會被展開

例子

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

print '第一個數(shù)組：' 
print a 
print '\n'  

print '未傳遞 Axis 參數(shù)。 在插入之前輸入數(shù)組會被展開柔昼。' 
print np.delete(a,5) 
print '\n'  

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

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

輸出如下：

第一個數(shù)組：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

未傳遞 Axis 參數(shù)哑芹。 在插入之前輸入數(shù)組會被展開。
[ 0 1 2 3 4 6 7 8 9 10 11]

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

包含從數(shù)組中刪除的替代值的切片：
[ 2 4 6 8 10]

numpy.unique

此函數(shù)返回輸入數(shù)組中的去重元素數(shù)組捕透。 該函數(shù)能夠返回一個元組聪姿，包含去重數(shù)組和相關索引的數(shù)組。 索引的性質(zhì)取決于函數(shù)調(diào)用中返回參數(shù)的類型激率。

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

其中：

• arr：輸入數(shù)組咳燕，如果不是一維數(shù)組則會展開
• return_index：如果為true勿决，返回輸入數(shù)組中的元素下標
• return_inverse：如果為true乒躺，返回去重數(shù)組的下標，它可以用于重構輸入數(shù)組
• return_counts：如果為true低缩，返回去重數(shù)組中的元素在原數(shù)組中的出現(xiàn)次數(shù)

例子

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

print '第一個數(shù)組：' 
print a 
print '\n'  

print '第一個數(shù)組的去重值：' 
u = np.unique(a) 
print u 
print '\n'  

print '去重數(shù)組的索引數(shù)組：' 
u,indices = np.unique(a, return_index = True) 
print indices 
print '\n'  

print '我們可以看到每個和原數(shù)組下標對應的數(shù)值：' 
print a 
print '\n'  

print '去重數(shù)組的下標：' 
u,indices = np.unique(a,return_inverse = True) 
print u 
print '\n' 

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

print '使用下標重構原數(shù)組：' 
print u[indices] 
print '\n'  

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

輸出如下：

第一個數(shù)組：
[5 2 6 2 7 5 6 8 2 9]

第一個數(shù)組的去重值：
[2 5 6 7 8 9]

去重數(shù)組的索引數(shù)組：
[1 0 2 4 7 9]

我們可以看到每個和原數(shù)組下標對應的數(shù)值：
[5 2 6 2 7 5 6 8 2 9]

去重數(shù)組的下標：
[2 5 6 7 8 9]

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

使用下標重構原數(shù)組：
[5 2 6 2 7 5 6 8 2 9]

返回唯一元素的重復數(shù)量：
[2 5 6 7 8 9]
 [3 2 2 1 1 1]

NumPy - 位操作

下面是 NumPy 包中可用的位操作函數(shù)嘉冒。

bitwise_and

通過np.bitwise_and()函數(shù)對輸入數(shù)組中的整數(shù)的二進制表示的相應位執(zhí)行位與運算曹货。

例子

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

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

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

bitwise_or

通過np.bitwise_or()函數(shù)對輸入數(shù)組中的整數(shù)的二進制表示的相應位執(zhí)行位或運算顶籽。

例子

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

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

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

invert

此函數(shù)計算輸入數(shù)組中整數(shù)的位非結果礼饱。 對于有符號整數(shù)，返回補碼究驴。

例子

import numpy as np 

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

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()函數(shù)返回給定寬度中十進制數(shù)的二進制表示。

left_shift

numpy.left shift()函數(shù)將數(shù)組元素的二進制表示中的位向左移動到指定位置熙侍，右側附加相等數(shù)量的 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()函數(shù)將數(shù)組元素的二進制表示中的位向右移動到指定位置，左側附加相等數(shù)量的 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 - 字符串函數(shù)

以下函數(shù)用于對dtype為numpy.string_或numpy.unicode_的數(shù)組執(zhí)行向量化字符串操作惩系。 它們基于 Python 內(nèi)置庫中的標準字符串函數(shù)位岔。

這些函數(shù)在字符數(shù)組類（numpy.char）中定義。 較舊的 Numarray 包包含chararray類爬坑。 numpy.char類中的上述函數(shù)在執(zhí)行向量化字符串操作時非常有用纠屋。

numpy.char.add()

函數(shù)執(zhí)行按元素的字符串連接。

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

這個函數(shù)執(zhí)行多重連接盾计。

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

輸出如下：

Hello Hello Hello 

numpy.char.center()

此函數(shù)返回所需寬度的數(shù)組售担，以便輸入字符串位于中心赁遗，并使用fillchar在左側和右側進行填充。

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

輸出如下：

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

numpy.char.capitalize()

函數(shù)返回字符串的副本族铆，其中第一個字母大寫

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

函數(shù)返回一個數(shù)組哥攘，其元素轉換為小寫剖煌。它對每個元素調(diào)用str.lower。

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

輸出如下：

['hello' 'world']
hello

numpy.char.upper()

函數(shù)返回一個數(shù)組逝淹，其元素轉換為大寫末捣。它對每個元素調(diào)用str.upper。

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

輸出如下：

HELLO
['HELLO' 'WORLD']

numpy.char.split()

此函數(shù)返回輸入字符串中的單詞列表创橄。 默認情況下箩做，空格用作分隔符。 否則妥畏，指定的分隔符字符用于分割字符串邦邦。

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

函數(shù)返回數(shù)組中元素的單詞列表，以換行符分割醉蚁。

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

函數(shù)返回數(shù)組的副本黔龟，其中元素移除了開頭或結尾處的特定字符。

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

這個函數(shù)返回一個字符串滥玷，其中單個字符由特定的分隔符連接氏身。

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

這個函數(shù)返回字符串副本，其中所有字符序列的出現(xiàn)位置都被另一個給定的字符序列取代惑畴。

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

輸出如下：

He was a good boy

numpy.char.decode()

這個函數(shù)在給定的字符串中使用特定編碼調(diào)用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()

此函數(shù)對數(shù)組中的每個元素調(diào)用str.encode函數(shù)。 默認編碼是utf_8如贷，可以使用標準 Python 庫中的編解碼器陷虎。

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

輸出如下：

\x88\x85\x93\x93\x96

NumPy - 算數(shù)函數(shù)

很容易理解的是，NumPy 包含大量的各種數(shù)學運算功能杠袱。 NumPy 提供標準的三角函數(shù)尚猿，算術運算的函數(shù)，復數(shù)處理函數(shù)等楣富。

三角函數(shù)

NumPy 擁有標準的三角函數(shù)凿掂，它為弧度制單位的給定角度返回三角函數(shù)比值。

示例

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  '數(shù)組中角度的余弦值：'  
print np.cos(a*np.pi/180)  
print  '\n'  
print  '數(shù)組中角度的正切值：'  
print np.tan(a*np.pi/180)  

輸出如下：

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

數(shù)組中角度的余弦值：                                         
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
   6.12323400e-17]                                                            

數(shù)組中角度的正切值：                                            
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
   1.63312394e+16]

arcsin菩彬，arccos缠劝，和arctan函數(shù)返回給定角度的sin潮梯，cos和tan的反三角函數(shù)骗灶。 這些函數(shù)的結果可以通過numpy.degrees()函數(shù)通過將弧度制轉換為角度制來驗證惨恭。

示例

import numpy as np
a = np.array([0,30,45,60,90])  
print  '含有正弦值的數(shù)組：'
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 函數(shù)行為類似：'
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 函數(shù)：'
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)  

輸出如下：

含有正弦值的數(shù)組：
[ 0.          0.5         0.70710678  0.8660254   1.        ]

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

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

arccos 和 arctan 函數(shù)行為類似：
[  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 函數(shù)：
[  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.]

舍入函數(shù)

numpy.around()

這個函數(shù)返回四舍五入到所需精度的值脱羡。 該函數(shù)接受以下參數(shù)。

numpy.around(a,decimals)

其中：

示例

import numpy as np
a = np.array([1.0,5.55,  123,  0.567,  25.532])  
print  '原數(shù)組：'  
print a
print  '\n'  
print  '舍入后：'  
print np.around(a)  
print np.around(a, decimals =  1)  
print np.around(a, decimals =  -1)

輸出如下：

原數(shù)組：                                                          
[   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()

此函數(shù)返回不大于輸入?yún)?shù)的最大整數(shù)绕娘。 即標量x 的下限是最大的整數(shù)i 脓规，使得i <= x。 注意在Python中险领，向下取整總是從 0 舍入侨舆。

示例

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  '提供的數(shù)組：'  
print a
print  '\n'  
print  '修改后的數(shù)組：'  
print np.floor(a)

輸出如下：

提供的數(shù)組：                                                            
[ -1.7   1.5  -0.2   0.6  10. ]

修改后的數(shù)組：                                                         
[ -2.   1.  -1.   0.  10.]

numpy.ceil()

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

示例

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  '提供的數(shù)組：'  
print a
print  '\n'  
print  '修改后的數(shù)組：'  
print np.ceil(a)

輸出如下：

提供的數(shù)組：
[ -1.7   1.5  -0.2   0.6  10. ]

修改后的數(shù)組：
[ -1.   2.  -0.   1.  10.]

NumPy - 算數(shù)運算

用于執(zhí)行算術運算（如add()脐湾，subtract()臭笆，multiply()和divide()）的輸入數(shù)組必須具有相同的形狀或符合數(shù)組廣播規(guī)則。

示例

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

輸出如下：

第一個數(shù)組：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

第二個數(shù)組：
[10 10 10]

兩個數(shù)組相加：
[[ 10. 11. 12.]
 [ 13. 14. 15.]
 [ 16. 17. 18.]]

兩個數(shù)組相減：
[[-10. -9. -8.]
 [ -7. -6. -5.]
 [ -4. -3. -2.]]

兩個數(shù)組相乘：
[[ 0. 10. 20.]
 [ 30. 40. 50.]
 [ 60. 70. 80.]]

兩個數(shù)組相除：
[[ 0. 0.1 0.2]
 [ 0.3 0.4 0.5]
 [ 0.6 0.7 0.8]]

讓我們現(xiàn)在來討論 NumPy 中提供的一些其他重要的算術函數(shù)秤掌。

numpy.reciprocal()

此函數(shù)返回參數(shù)逐元素的倒數(shù)愁铺，诵次。 由于 Python 處理整數(shù)除法的方式榛搔，對于絕對值大于 1 的整數(shù)元素禽作，結果始終為 0湾盗， 對于整數(shù) 0谎痢，則發(fā)出溢出警告扑庞。

示例

import numpy as np 
a = np.array([0.25,  1.33,  1,  0,  100])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 reciprocal 函數(shù)：'  
print np.reciprocal(a)  
print  '\n' 
b = np.array([100], dtype =  int)  
print  '第二個數(shù)組：'  
print b 
print  '\n'  
print  '調(diào)用 reciprocal 函數(shù)：'  
print np.reciprocal(b)  

輸出如下：

我們的數(shù)組是：                                                               
[   0.25    1.33    1.      0.    100.  ]                                     

調(diào)用 reciprocal 函數(shù)：                                         
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal           
  print np.reciprocal(a)                                                      
[ 4.         0.7518797  1.               inf  0.01     ]                      

第二個數(shù)組：                                                      
[100]                                                                         

調(diào)用 reciprocal 函數(shù)：                                        
[0]                         

numpy.power()

此函數(shù)將第一個輸入數(shù)組中的元素作為底數(shù)屏积，計算它與第二個輸入數(shù)組中相應元素的冪痹雅。

import numpy as np 
a = np.array([10,100,1000])  
print  '我們的數(shù)組是蚀苛；'  
print a 
print  '\n'  
print  '調(diào)用 power 函數(shù)：'  
print np.power(a,2)  
print  '\n'  
print  '第二個數(shù)組：' 
b = np.array([1,2,3])  
print b 
print  '\n'  
print  '再次調(diào)用 power 函數(shù)：'  
print np.power(a,b)

輸出如下：

我們的數(shù)組是在验；                                                              
[  10  100 1000]                                                              

調(diào)用 power 函數(shù)：                                                    
[    100   10000 1000000]                                                     

第二個數(shù)組：                                                              
[1 2 3]                                                                       

再次調(diào)用 power 函數(shù)：                                              
[        10      10000 1000000000] 

numpy.mod()

此函數(shù)返回輸入數(shù)組中相應元素的除法余數(shù)。 函數(shù)numpy.remainder()也產(chǎn)生相同的結果堵未。

import numpy as np 
a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print  '第一個數(shù)組：'  
print a 
print  '\n'  
print  '第二個數(shù)組：'  
print b 
print  '\n' 
print  '調(diào)用 mod() 函數(shù)：'  
print np.mod(a,b)  
print  '\n'  
print  '調(diào)用 remainder() 函數(shù)：'  
print np.remainder(a,b)  

輸出如下：

第一個數(shù)組：
[10 20 30]

第二個數(shù)組：
[3 5 7]

調(diào)用 mod() 函數(shù)：                                                     
[1 0 2]

調(diào)用 remainder() 函數(shù)：                                              
[1 0 2]

以下函數(shù)用于對含有復數(shù)的數(shù)組執(zhí)行操作腋舌。

• numpy.real() 返回復數(shù)類型參數(shù)的實部。

• numpy.imag() 返回復數(shù)類型參數(shù)的虛部渗蟹。

• numpy.conj() 返回通過改變虛部的符號而獲得的共軛復數(shù)块饺。

• numpy.angle() 返回復數(shù)參數(shù)的角度赞辩。 函數(shù)的參數(shù)是degree。 如果為true授艰，返回的角度以角度制來表示辨嗽，否則為以弧度制來表示。

import numpy as np 
a = np.array([-5.6j,  0.2j,  11.  ,  1+1j])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 real() 函數(shù)：'  
print np.real(a)  
print  '\n'  
print  '調(diào)用 imag() 函數(shù)：'  
print np.imag(a)  
print  '\n'  
print  '調(diào)用 conj() 函數(shù)：'  
print np.conj(a)  
print  '\n'  
print  '調(diào)用 angle() 函數(shù)：'  
print np.angle(a)  
print  '\n'  
print  '再次調(diào)用 angle() 函數(shù)（以角度制返回）：'  
print np.angle(a, deg =  True)

輸出如下：

我們的數(shù)組是：
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]

調(diào)用 real() 函數(shù)：
[ 0. 0. 11. 1.]

調(diào)用 imag() 函數(shù)：
[-5.6 0.2 0. 1. ]

調(diào)用 conj() 函數(shù)：
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]

調(diào)用 angle() 函數(shù)：
[-1.57079633 1.57079633 0. 0.78539816]

再次調(diào)用 angle() 函數(shù)（以角度制返回）：
[-90. 90. 0. 45.]

NumPy - 統(tǒng)計函數(shù)

NumPy 有很多有用的統(tǒng)計函數(shù)淮腾，用于從數(shù)組中給定的元素中查找最小糟需，最大，百分標準差和方差等谷朝。 函數(shù)說明如下：

numpy.amin() 和 numpy.amax()

這些函數(shù)從給定數(shù)組中的元素沿指定軸返回最小值和最大值洲押。

示例

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 amin() 函數(shù)：'  
print np.amin(a,1)  
print  '\n'  
print  '再次調(diào)用 amin() 函數(shù)：'  
print np.amin(a,0)  
print  '\n'  
print  '調(diào)用 amax() 函數(shù)：'  
print np.amax(a)  
print  '\n'  
print  '再次調(diào)用 amax() 函數(shù)：'  
print np.amax(a, axis =  0)

輸出如下：

我們的數(shù)組是：
[[3 7 5]
[8 4 3]
[2 4 9]]

調(diào)用 amin() 函數(shù)：
[3 3 2]

再次調(diào)用 amin() 函數(shù)：
[2 4 3]

調(diào)用 amax() 函數(shù)：
9

再次調(diào)用 amax() 函數(shù)：
[8 7 9]

numpy.ptp()

numpy.ptp()函數(shù)返回沿軸的值的范圍（最大值 - 最小值）。

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 ptp() 函數(shù)：'  
print np.ptp(a)  
print  '\n'  
print  '沿軸 1 調(diào)用 ptp() 函數(shù)：'  
print np.ptp(a, axis =  1)  
print  '\n'  
print  '沿軸 0 調(diào)用 ptp() 函數(shù)：'  
print np.ptp(a, axis =  0)  

輸出如下：

我們的數(shù)組是：
[[3 7 5]
[8 4 3]
[2 4 9]]

調(diào)用 ptp() 函數(shù)：
7

沿軸 1 調(diào)用 ptp() 函數(shù)：
[4 5 7]

沿軸 0 調(diào)用 ptp() 函數(shù)：
[6 3 6]

numpy.percentile()

百分位數(shù)是統(tǒng)計中使用的度量圆凰，表示小于這個值得觀察值占某個百分比杈帐。 函數(shù)numpy.percentile()接受以下參數(shù)。

numpy.percentile(a, q, axis)

其中：

示例

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 percentile() 函數(shù)：'  
print np.percentile(a,50)  
print  '\n'  
print  '沿軸 1 調(diào)用 percentile() 函數(shù)：'  
print np.percentile(a,50, axis =  1)  
print  '\n'  
print  '沿軸 0 調(diào)用 percentile() 函數(shù)：'  
print np.percentile(a,50, axis =  0)

輸出如下：

我們的數(shù)組是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]

調(diào)用 percentile() 函數(shù)：
50.0

沿軸 1 調(diào)用 percentile() 函數(shù)：
[ 40. 20. 60.]

沿軸 0 調(diào)用 percentile() 函數(shù)：
[ 50. 40. 60.]

numpy.median()

中值定義為將數(shù)據(jù)樣本的上半部分與下半部分分開的值挑童。 numpy.median()函數(shù)的用法如下面的程序所示。

示例

import numpy as np 
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 median() 函數(shù)：'  
print np.median(a)  
print  '\n'  
print  '沿軸 0 調(diào)用 median() 函數(shù)：'  
print np.median(a, axis =  0)  
print  '\n'  
print  '沿軸 1 調(diào)用 median() 函數(shù)：'  
print np.median(a, axis =  1)

輸出如下：

我們的數(shù)組是：
[[30 65 70]
 [80 95 10]
 [50 90 60]]

調(diào)用 median() 函數(shù)：
65.0

沿軸 0 調(diào)用 median() 函數(shù)：
[ 50. 90. 60.]

沿軸 1 調(diào)用 median() 函數(shù)：
[ 65. 80. 60.]

numpy.mean()

算術平均值是沿軸的元素的總和除以元素的數(shù)量驶沼。 numpy.mean()函數(shù)返回數(shù)組中元素的算術平均值炮沐。 如果提供了軸，則沿其計算回怜。

示例

import numpy as np 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 mean() 函數(shù)：'  
print np.mean(a)  
print  '\n'  
print  '沿軸 0 調(diào)用 mean() 函數(shù)：'  
print np.mean(a, axis =  0)  
print  '\n'  
print  '沿軸 1 調(diào)用 mean() 函數(shù)：'  
print np.mean(a, axis =  1)

輸出如下：

我們的數(shù)組是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]

調(diào)用 mean() 函數(shù)：
3.66666666667

沿軸 0 調(diào)用 mean() 函數(shù)：
[ 2.66666667 3.66666667 4.66666667]

沿軸 1 調(diào)用 mean() 函數(shù)：
[ 2. 4. 5.]

numpy.average()

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

考慮數(shù)組[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  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 average() 函數(shù)：'  
print np.average(a)  
print  '\n'  
# 不指定權重時相當于 mean 函數(shù)
wts = np.array([4,3,2,1])  
print  '再次調(diào)用 average() 函數(shù)：'  
print np.average(a,weights = wts)  
print  '\n'  
# 如果 returned 參數(shù)設為 true怔球，則返回權重的和  
print  '權重的和：'  
print np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True)

輸出如下：

我們的數(shù)組是：
[1 2 3 4]

調(diào)用 average() 函數(shù)：
2.5

再次調(diào)用 average() 函數(shù)：
2.0

權重的和：
(2.0, 10.0)

在多維數(shù)組中普泡，可以指定用于計算的軸斟冕。

示例

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

輸出如下：

我們的數(shù)組是：
[[0 1]
 [2 3]
 [4 5]]

修改后的數(shù)組：
[ 0.625 2.625 4.625]

修改后的數(shù)組：
(array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))

標準差

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

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

如果數(shù)組是[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 - 排序肌索、搜索和計數(shù)函數(shù)

NumPy中提供了各種排序相關功能。 這些排序函數(shù)實現(xiàn)不同的排序算法特碳，每個排序算法的特征在于執(zhí)行速度诚亚，最壞情況性能，所需的工作空間和算法的穩(wěn)定性午乓。 下表顯示了三種排序算法的比較站宗。

numpy.sort()

sort()函數(shù)返回輸入數(shù)組的排序副本。 它有以下參數(shù)：

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

其中：

示例

import numpy as np  
a = np.array([[3,7],[9,1]])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 sort() 函數(shù)：'  
print np.sort(a)  
print  '\n'  
print  '沿軸 0 排序：'  
print np.sort(a, axis =  0)  
print  '\n'  
# 在 sort 函數(shù)中排序字段 
dt = np.dtype([('name',  'S10'),('age',  int)]) 
a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '按 name 排序：'  
print np.sort(a, order =  'name')

輸出如下：

我們的數(shù)組是：
[[3 7]
 [9 1]]

調(diào)用 sort() 函數(shù)：
[[3 7]
 [1 9]]

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

我們的數(shù)組是：
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]

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

numpy.argsort()

numpy.argsort()函數(shù)對輸入數(shù)組沿給定軸執(zhí)行間接排序蒸其，并使用指定排序類型返回數(shù)據(jù)的索引數(shù)組敏释。 這個索引數(shù)組用于構造排序后的數(shù)組。

示例

import numpy as np 
x = np.array([3,  1,  2])  
print  '我們的數(shù)組是：'  
print x 
print  '\n'  
print  '對 x 調(diào)用 argsort() 函數(shù)：' 
y = np.argsort(x)  
print y 
print  '\n'  
print  '以排序后的順序重構原數(shù)組：'  
print x[y]  
print  '\n'  
print  '使用循環(huán)重構原數(shù)組：'  
for i in y:  
    print x[i],

輸出如下：

我們的數(shù)組是：
[3 1 2]

對 x 調(diào)用 argsort() 函數(shù)：
[1 2 0]

以排序后的順序重構原數(shù)組：
[1 2 3]

使用循環(huán)重構原數(shù)組：
1 2 3

numpy.lexsort()

函數(shù)使用鍵序列執(zhí)行間接排序摸袁。 鍵可以看作是電子表格中的一列钥顽。 該函數(shù)返回一個索引數(shù)組，使用它可以獲得排序數(shù)據(jù)靠汁。 注意蜂大，最后一個鍵恰好是 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  '調(diào)用 lexsort() 函數(shù)：'  
print ind 
print  '\n'  
print  '使用這個索引來獲取排序后的數(shù)據(jù)：'  
print  [nm[i]  +  ", "  + dv[i]  for i in ind]  

輸出如下：

調(diào)用 lexsort() 函數(shù)：
[3 1 0 2]

使用這個索引來獲取排序后的數(shù)據(jù)：
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

NumPy 模塊有一些用于在數(shù)組內(nèi)搜索的函數(shù)蝶怔。 提供了用于找到最大值奶浦，最小值以及滿足給定條件的元素的函數(shù)。

numpy.argmax() 和 numpy.argmin()

這兩個函數(shù)分別沿給定軸返回最大和最小元素的索引踢星。

示例

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 argmax() 函數(shù)：'  
print np.argmax(a)  
print  '\n'  
print  '展開數(shù)組：'  
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  '調(diào)用 argmin() 函數(shù)：' 
minindex = np.argmin(a)  
print minindex 
print  '\n'  
print  '展開數(shù)組中的最小值：'  
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

輸出如下：

我們的數(shù)組是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]

調(diào)用 argmax() 函數(shù)：
7

展開數(shù)組：
[30 40 70 80 20 10 50 90 60]

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

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

調(diào)用 argmin() 函數(shù)：
5

展開數(shù)組中的最小值：
10

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

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

numpy.nonzero()

numpy.nonzero()函數(shù)返回輸入數(shù)組中非零元素的索引澳叉。

示例

import numpy as np 
a = np.array([[30,40,0],[0,20,10],[50,0,60]])  
print  '我們的數(shù)組是：'  
print a 
print  '\n'  
print  '調(diào)用 nonzero() 函數(shù)：'  
print np.nonzero (a)

輸出如下：

我們的數(shù)組是：
[[30 40 0]
 [ 0 20 10]
 [50 0 60]]

調(diào)用 nonzero() 函數(shù)：
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

numpy.where()

where()函數(shù)返回輸入數(shù)組中滿足給定條件的元素的索引。

示例

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

輸出如下：

我們的數(shù)組是：
[[ 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()函數(shù)返回滿足任何條件的元素斩狱。

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

輸出如下：

我們的數(shù)組是：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

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

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

NumPy - 字節(jié)交換

我們已經(jīng)看到耳高，存儲在計算機內(nèi)存中的數(shù)據(jù)取決于 CPU 使用的架構。 它可以是小端（最小有效位存儲在最小地址中）或大端（最小有效字節(jié)存儲在最大地址中）所踊。

numpy.ndarray.byteswap()

numpy.ndarray.byteswap()函數(shù)在兩個表示：大端和小端之間切換泌枪。

import numpy as np 
a = np.array([1,  256,  8755], dtype = np.int16)  
print  '我們的數(shù)組是：'  
print a 
print  '以十六進制表示內(nèi)存中的數(shù)據(jù)：'  
print map(hex,a)  
# byteswap() 函數(shù)通過傳入 true 來原地交換 
print  '調(diào)用 byteswap() 函數(shù)：'  
print a.byteswap(True)  
print  '十六進制形式：'  
print map(hex,a)  
# 我們可以看到字節(jié)已經(jīng)交換了

輸出如下：

我們的數(shù)組是：
[1 256 8755]

以十六進制表示內(nèi)存中的數(shù)據(jù)：
['0x1', '0x100', '0x2233']

調(diào)用 byteswap() 函數(shù)：
[256 1 13090]

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

NumPy - 副本和視圖

在執(zhí)行函數(shù)時，其中一些返回輸入數(shù)組的副本秕岛，而另一些返回視圖碌燕。 當內(nèi)容物理存儲在另一個位置時误证，稱為副本。 另一方面修壕，如果提供了相同內(nèi)存內(nèi)容的不同視圖愈捅，我們將其稱為視圖。

無復制

簡單的賦值不會創(chuàng)建數(shù)組對象的副本慈鸠。 相反蓝谨，它使用原始數(shù)組的相同id()來訪問它。 id()返回 Python 對象的通用標識符青团，類似于 C 中的指針譬巫。

此外，一個數(shù)組的任何變化都反映在另一個數(shù)組上督笆。 例如芦昔，一個數(shù)組的形狀改變也會改變另一個數(shù)組的形狀。

示例

import numpy as np 
a = np.arange(6)  
print  '我們的數(shù)組是：'  
print a 
print  '調(diào)用 id() 函數(shù)：'  
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

輸出如下：

我們的數(shù)組是：
[0 1 2 3 4 5]

調(diào)用 id() 函數(shù)：
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()方法娃肿，它是一個新的數(shù)組對象咕缎，并可查看原始數(shù)組的相同數(shù)據(jù)。 與前一種情況不同料扰，新數(shù)組的維數(shù)更改不會更改原始數(shù)據(jù)的維數(shù)凭豪。

示例

import numpy as np 
# 最開始 a 是個 3X2 的數(shù)組
a = np.arange(6).reshape(3,2)  
print  '數(shù)組 a：'  
print a 
print  '創(chuàng)建 a 的視圖：' 
b = a.view()  
print b 
print  '兩個數(shù)組的 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

輸出如下：

數(shù)組 a：
[[0 1]
 [2 3]
 [4 5]]

創(chuàng)建 a 的視圖：
[[0 1]
 [2 3]
 [4 5]]

兩個數(shù)組的 id() 不同：
a 的 id()：
140424307227264
b 的 id()：
140424151696288

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

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

數(shù)組的切片也會創(chuàng)建視圖：

示例

import numpy as np 
a = np.array([[10,10],  [2,3],  [4,5]])  
print  '我們的數(shù)組：'  
print a 
print  '創(chuàng)建切片：' 
s = a[:,  :2]  
print s 

輸出如下：

我們的數(shù)組：
[[10 10]
 [ 2 3]
 [ 4 5]]

創(chuàng)建切片：
[[10 10]
 [ 2 3]
 [ 4 5]]

深復制

ndarray.copy()函數(shù)創(chuàng)建一個深層副本记罚。 它是數(shù)組及其數(shù)據(jù)的完整副本墅诡，不與原始數(shù)組共享。

示例

import numpy as np 
a = np.array([[10,10],  [2,3],  [4,5]])  
print  '數(shù)組 a：'  
print a 
print  '創(chuàng)建 a 的深層副本：' 
b = a.copy()  
print  '數(shù)組 b：'  
print b 
# b 與 a 不共享任何內(nèi)容  
print  '我們能夠?qū)懭?b 來寫入 a 嗎桐智？'  
print b is a 
print  '修改 b 的內(nèi)容：' 
b[0,0]  =  100  
print  '修改后的數(shù)組 b：'  
print b 
print  'a 保持不變：'  
print a

輸出如下：

數(shù)組 a：
[[10 10]
 [ 2 3]
 [ 4 5]]

創(chuàng)建 a 的深層副本：
數(shù)組 b：
[[10 10]
 [ 2 3]
 [ 4 5]]
我們能夠?qū)懭?b 來寫入 a 嗎？
False

修改 b 的內(nèi)容：
修改后的數(shù)組 b：
[[100 10]
 [ 2 3]
 [ 4 5]]

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

NumPy - 矩陣庫

NumPy 包包含一個 Matrix庫numpy.matlib烟馅。此模塊的函數(shù)返回矩陣而不是返回ndarray對象说庭。

matlib.empty()

matlib.empty()函數(shù)返回一個新的矩陣，而不初始化元素郑趁。 該函數(shù)接受以下參數(shù)刊驴。

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

其中：

示例

import numpy.matlib 
import numpy as np 
print np.matlib.empty((2,2))  
# 填充為隨機數(shù)據(jù)

輸出如下：

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

numpy.matlib.zeros()

此函數(shù)返回以零填充的矩陣寡润。

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

輸出如下：

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

numpy.matlib.ones()

此函數(shù)返回以一填充的矩陣捆憎。

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

輸出如下：

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

numpy.matlib.eye()

這個函數(shù)返回一個矩陣，對角線元素為 1梭纹，其他位置為零躲惰。 該函數(shù)接受以下參數(shù)。

numpy.matlib.eye(n, M,k, 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()函數(shù)返回給定大小的單位矩陣础拨。單位矩陣是主對角線元素都為 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()`函數(shù)返回給定大小的填充隨機值的矩陣。

示例

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 維數(shù)組。 兩個對象都是可互換的塔沃。

示例

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 - 線性代數(shù)

NumPy 包包含numpy.linalg模塊蝠引，提供線性代數(shù)所需的所有功能。 此模塊中的一些重要功能如下表所述蛀柴。

numpy.dot()

此函數(shù)返回兩個數(shù)組的點積立肘。 對于二維向量，其等效于矩陣乘法名扛。 對于一維數(shù)組谅年，它是向量的內(nèi)積。 對于 N 維數(shù)組肮韧，它是a的最后一個軸上的和與b的倒數(shù)第二個軸的乘積融蹂。

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

此函數(shù)返回兩個向量的點積。 如果第一個參數(shù)是復數(shù)弄企，那么它的共軛復數(shù)會用于計算超燃。 如果參數(shù)id是多維數(shù)組，它會被展開拘领。

例子

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

輸出如下：

130

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

numpy.inner()

此函數(shù)返回一維數(shù)組的向量內(nèi)積。 對于更高的維度约素，它返回最后一個軸上的和的乘積届良。

例子

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

輸出如下：

2

例子

# 多維數(shù)組示例 
import numpy as np 
a = np.array([[1,2], [3,4]]) 

print '數(shù)組 a：' 
print a 
b = np.array([[11, 12], [13, 14]]) 

print '數(shù)組 b：' 
print b 

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

輸出如下：

數(shù)組 a：
[[1 2]
[3 4]]

數(shù)組 b：
[[11 12]
[13 14]]

內(nèi)積：
[[35 41]
[81 95]]

上面的例子中，內(nèi)積計算如下：

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

numpy.matmul

numpy.matmul()函數(shù)返回兩個數(shù)組的矩陣乘積圣猎。 雖然它返回二維數(shù)組的正常乘積士葫，但如果任一參數(shù)的維數(shù)大于2，則將其視為存在于最后兩個索引的矩陣的棧送悔，并進行相應廣播慢显。

另一方面，如果任一參數(shù)是一維數(shù)組欠啤，則通過在其維度上附加 1 來將其提升為矩陣荚藻，并在乘法之后被去除。

例子

# 對于二維數(shù)組洁段，它就是矩陣乘法
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] 

例子

# 維度大于二的數(shù)組 
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()

行列式在線性代數(shù)中是非常有用的值应狱。 它從方陣的對角元素計算。 對于 2×2 矩陣眉撵，它是左上和右下元素的乘積與其他兩個的乘積的差侦香。

換句話說落塑，對于矩陣[[a，b]罐韩，[c憾赁，d]]，行列式計算為ad-bc散吵。 較大的方陣被認為是 2×2 矩陣的組合龙考。

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

例子

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()函數(shù)給出了矩陣形式的線性方程的解矾睦。

考慮以下線性方程：

x + y + z = 6

2y + 5z = -4

2x + 5y - z = 27

可以使用矩陣表示為：

如果矩陣成為A晦款、X和B，方程變?yōu)椋?/p>

AX = B  

或

X = A^(-1)B 

numpy.linalg.inv()

我們使用numpy.linalg.inv()函數(shù)來計算矩陣的逆枚冗。 矩陣的逆是這樣的缓溅，如果它乘以原始矩陣，則得到單位矩陣赁温。

例子

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

例子

現(xiàn)在讓我們在示例中創(chuàng)建一個矩陣A的逆坛怪。

import numpy as np 
a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 

print '數(shù)組 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 的解

輸出如下：

數(shù)組 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.]]

結果也可以使用下列函數(shù)獲取

x = np.dot(ainv,b)

NumPy - Matplotlib

Matplotlib 是 Python 的繪圖庫。 它可與 NumPy 一起使用股囊，提供了一種有效的 MatLab 開源替代方案袜匿。 它也可以和圖形工具包一起使用，如 PyQt 和 wxPython稚疹。

Matplotlib 模塊最初是由 John D. Hunter 編寫的居灯。 自 2012 年以來，Michael Droettboom 是主要開發(fā)者内狗。 目前怪嫌，Matplotlib 1.5.1 是可用的穩(wěn)定版本。 該軟件包可以二進制分發(fā)其屏，其源代碼形式在 www.matplotlib.org 上提供喇勋。

通常，通過添加以下語句將包導入到 Python 腳本中：

from matplotlib import pyplot as plt

這里pyplot()是 matplotlib 庫中最重要的函數(shù)偎行，用于繪制 2D 數(shù)據(jù)。 以下腳本繪制方程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()函數(shù)創(chuàng)建為x軸上的值贰拿。y軸上的對應值存儲在另一個數(shù)組對象y中蛤袒。 這些值使用matplotlib軟件包的pyplot子模塊的plot()函數(shù)繪制。

圖形由show()函數(shù)展示膨更。

上面的代碼應該產(chǎn)生以下輸出：

Matplotlib Demo

作為線性圖的替代妙真，可以通過向plot()函數(shù)添加格式字符串來顯示離散值。 可以使用以下格式化字符荚守。

還定義了以下顏色縮寫珍德。

要顯示圓來代表點练般，而不是上面示例中的線，請使用ob作為plot()函數(shù)中的格式字符串锈候。

示例

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

上面的代碼應該產(chǎn)生以下輸出：

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()函數(shù)允許你在同一圖中繪制不同的東西。 在下面的腳本中泵琳，繪制正弦和余弦值摄职。

示例

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 網(wǎng)格，高為 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()

上面的代碼應該產(chǎn)生以下輸出：

Sub Plot

bar()

pyplot子模塊提供bar()函數(shù)來生成條形圖。 以下示例生成兩組x和y數(shù)組的條形圖击孩。

示例

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()函數(shù)迫悠，它是數(shù)據(jù)的頻率分布的圖形表示。 水平尺寸相等的矩形對應于類間隔巩梢，稱為bin勺远，變量height對應于頻率。

numpy.histogram()

numpy.histogram()函數(shù)將輸入數(shù)組和bin作為兩個參數(shù)亡资。 bin數(shù)組中的連續(xù)元素用作每個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 可以將直方圖的數(shù)字表示轉換為圖形。 pyplot子模塊的plt()函數(shù)將包含數(shù)據(jù)和bin數(shù)組的數(shù)組作為參數(shù)又跛，并轉換為直方圖碍拆。

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()函數(shù)處理 numPy 二進制文件（帶npy擴展名）

• loadtxt()和savetxt()函數(shù)處理正常的文本文件

NumPy 為ndarray對象引入了一個簡單的文件格式慨蓝。 這個npy文件在磁盤文件中感混，存儲重建ndarray所需的數(shù)據(jù)、圖形礼烈、dtype和其他信息弧满，以便正確獲取數(shù)組，即使該文件在具有不同架構的另一臺機器上此熬。

numpy.save()

numpy.save()文件將輸入數(shù)組存儲在具有npy擴展名的磁盤文件中庭呜。

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

為了從outfile.npy重建數(shù)組，請使用load()函數(shù)犀忱。

import numpy as np 
b = np.load('outfile.npy')  
print b 

輸出如下：

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

save()和load()函數(shù)接受一個附加的布爾參數(shù)allow_pickles募谎。 Python 中的pickle用于在保存到磁盤文件或從磁盤文件讀取之前，對對象進行序列化和反序列化阴汇。

savetxt()

以簡單文本文件格式存儲和獲取數(shù)組數(shù)據(jù)数冬，是通過savetxt()和loadtx()函數(shù)完成的。

示例

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()數(shù)接受附加的可選參數(shù)搀庶，例如頁首拐纱，頁尾和分隔符铜异。

NumPy - 實用資源

以下資源包含有關 NumPy 的其他信息。 請使用它們獲得更多的深入知識秸架。

• 試驗性 Numpy 教程
• 100 numpy exercises
• From Python to Numpy
• Matplotlib 教程