NumPy 快速指南

---

---

NumPy - 简介

NumPy 是一个 Python 包。它代表“Numerical Python”。它是一个包含多维数组对象和用于数组处理的例程集合的库。

Numeric，NumPy 的祖先，由 Jim Hugunin 开发。另一个名为 Numarray 的包也得到了开发，它具有一些额外的功能。2005 年，Travis Oliphant 通过将 Numarray 的功能整合到 Numeric 包中创建了 NumPy 包。许多贡献者参与了这个开源项目。

使用 NumPy 进行的操作

使用 NumPy，开发人员可以执行以下操作：

• 数组上的数学和逻辑运算。

• 傅里叶变换和形状操作例程。

• 与线性代数相关的运算。NumPy 具有用于线性代数和随机数生成的内置函数。

NumPy – MatLab 的替代品

NumPy 通常与 SciPy（科学 Python）和 Mat−plotlib（绘图库）等包一起使用。这种组合被广泛用作 MatLab 的替代品，MatLab 是一个流行的技术计算平台。然而，Python 的 MatLab 替代方案现在被视为一种更现代和完整的编程语言。

它是开源的，这是 NumPy 的一个额外优势。

NumPy - 环境配置

标准 Python 发行版不包含 NumPy 模块。一种轻量级的替代方法是使用流行的 Python 包安装程序 pip 来安装 NumPy。

pip install numpy

启用 NumPy 的最佳方法是使用特定于您操作系统的可安装二进制包。这些二进制文件包含完整的 SciPy 堆栈（包括 NumPy、SciPy、matplotlib、IPython、SymPy 和 nose 包以及核心 Python）。

Windows

Anaconda（来自 https://www.continuum.io）是 SciPy 堆栈的免费 Python 发行版。它也适用于 Linux 和 Mac。

Canopy（https://www.enthought.com/products/canopy/）作为免费和商业发行版提供，包含适用于 Windows、Linux 和 Mac 的完整 SciPy 堆栈。

Python (x,y)：这是一个免费的 Python 发行版，包含 SciPy 堆栈和适用于 Windows 操作系统的 Spyder IDE。（可从 https://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 提示符导入它。

import numpy

如果未安装，将显示以下错误消息。

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

或者，可以使用以下语法导入 NumPy 包：

import numpy as np

NumPy - Ndarray 对象

NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型。它描述了相同类型项目的集合。可以使用基于零的索引访问集合中的项目。

ndarray 中的每个项目在内存中占用相同大小的块。ndarray 中的每个元素都是数据类型对象（称为 dtype）的对象。

从 ndarray 对象（通过切片）提取的任何项目都由一个数组标量类型的 Python 对象表示。下图显示了 ndarray、数据类型对象（dtype）和数组标量类型之间的关系：

可以通过后面教程中描述的不同数组创建例程来构造 ndarray 类的实例。使用 NumPy 中的 array 函数创建基本 ndarray，如下所示：

numpy.array 

它从任何公开数组接口的对象或返回数组的任何方法创建 ndarray。

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

上述构造函数采用以下参数：

请查看以下示例以更好地理解。

示例 1

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

输出如下：

[1, 2, 3]

示例 2

# more than one dimensions 
import numpy as np 
a = np.array([[1, 2], [3, 4]]) 
print a

输出如下：

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

示例 3

# minimum dimensions 
import numpy as np 
a = np.array([1, 2, 3,4,5], ndmin = 2) 
print a

输出如下：

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

示例 4

# dtype parameter 
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 中定义的不同标量数据类型。

NumPy 数值类型是 dtype（数据类型）对象的实例，每个对象都具有独特的特性。dtype 可用作 np.bool_、np.float32 等。

数据类型对象 (dtype)

数据类型对象描述了对应于数组的固定内存块的解释，具体取决于以下方面：

• 数据类型（整数、浮点数或 Python 对象）

• 数据大小

• 字节序（小端或大端）

• 对于结构化类型，包括字段名称、每个字段的数据类型以及每个字段占据的内存块部分。

• 如果数据类型是子数组，则包括其形状和数据类型

字节序通过在数据类型前加“<”或“>”来确定。“<”表示编码是小端序（最低有效字节存储在最小地址中）。“>”表示编码是大端序（最高有效字节存储在最小地址中）。

使用以下语法构造 dtype 对象：

numpy.dtype(object, align, copy)

参数如下：

• 对象 - 转换为数据类型对象

• Align - 如果为 True，则向字段添加填充，使其与 C 结构体类似

• Copy - 创建 dtype 对象的新副本。如果为 False，则结果是对内置数据类型对象的引用

示例 1

# using array-scalar type 
import numpy as np 
dt = np.dtype(np.int32) 
print dt

输出如下：

int32

示例 2

#int8, int16, int32, int64 can be replaced by equivalent string 'i1', 'i2','i4', etc. 
import numpy as np 

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

输出如下：

int32

示例 3

# using endian notation 
import numpy as np 
dt = np.dtype('>i4') 
print dt

输出如下：

>i4

以下示例展示了结构化数据类型的用法。这里需要声明字段名称和对应的标量数据类型。

示例 4

# first create structured data type 
import numpy as np 
dt = np.dtype([('age',np.int8)]) 
print dt 

输出如下：

[('age', 'i1')] 

示例 5

# now apply it to ndarray object 
import numpy as np 

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

输出如下：

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

示例 6

# file name can be used to access content of age column 
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' - 原始数据（空值）

NumPy - 数组属性

在本节中，我们将讨论 NumPy 的各种数组属性。

ndarray.shape

此数组属性返回一个包含数组维度的元组。它还可以用于调整数组大小。

示例 1

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

输出如下：

(2, 3)

示例 2

# this resizes the ndarray 
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

# an array of evenly spaced numbers 
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

# this is one dimensional array 
import numpy as np 
a = np.arange(24) 
a.ndim  

# now reshape it 
b = a.reshape(2,4,3) 
print b 
# b is having three dimensions

输出如下：

[[[ 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 of array is int8 (1 byte) 
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.int8) 
print x.itemsize

输出如下：

1

示例 2

# dtype of array is now float32 (4 bytes) 
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.float32) 
print x.itemsize

输出如下：

4

numpy.flags

ndarray 对象具有以下属性。此函数返回其当前值。

示例

以下示例显示了标志的当前值。

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

构造函数采用以下参数。

示例

以下代码显示了一个空数组的示例。

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

输出如下：

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

注意 - 数组中的元素显示随机值，因为它们未初始化。

numpy.zeros

返回一个指定大小的新数组，填充为零。

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

构造函数采用以下参数。

示例 1

# array of five zeros. Default dtype is 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

# custom type 
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

# array of five ones. Default dtype is 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)

构造函数采用以下参数。

以下示例显示了如何使用asarray函数。

示例 1

# convert list to ndarray 
import numpy as np 

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

其输出将如下所示：

[1  2  3] 

示例 2

# dtype is set 
import numpy as np 

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

现在，输出将如下所示：

[ 1.  2.  3.] 

示例 3

# ndarray from tuple 
import numpy as np 

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

其输出将为：

[1  2  3]

示例 4

# ndarray from list of tuples 
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)

构造函数采用以下参数。

示例

以下示例演示了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)

这里，构造函数采用以下参数。

以下示例演示了如何使用内置range()函数返回列表对象。此列表的迭代器用于形成ndarray对象。

示例 1

# create list object using range function 
import numpy as np 
list = range(5) 
print list

其输出如下所示：

[0,  1,  2,  3,  4]

示例 2

# obtain iterator object from list 
import numpy as np 
list = range(5) 
it = iter(list)  

# use iterator to create 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

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

其输出将如下所示：

[0  1  2  3  4]

示例 2

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

这里，输出将为：

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

示例 3

# start and stop parameters set 
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)

构造函数采用以下参数。

以下示例演示了linspace函数的用法。

示例 1

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

其输出将为：

[10.   12.5   15.   17.5  20.]

示例 2

# endpoint set to false 
import numpy as np 
x = np.linspace(10,20, 5, endpoint = False) 
print x

输出将为：

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

示例 3

# find retstep value 
import numpy as np 

x = np.linspace(1,2,5, retstep = True) 
print x 
# retstep here is 0.25

现在，输出将为：

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

numpy.logspace

此函数返回一个ndarray对象，其中包含对数刻度上等间距的数字。刻度的起始和结束端点是底数（通常为 10）的指数。

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

以下参数确定logspace函数的输出。

以下示例将帮助您理解logspace函数。

示例 1

import numpy as np 
# default base is 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

# set base of log space to 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 维。Python 切片对象是通过向内置slice函数提供start、stop和step参数来构造的。此切片对象传递给数组以提取数组的一部分。

示例 1

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

其输出如下所示：

[2  4  6]

在上面的示例中，ndarray对象由arange()函数准备。然后定义一个切片对象，其 start、stop 和 step 值分别为 2、7 和 2。当此切片对象传递给 ndarray 时，它的一部分（从索引 2 开始到 7，步长为 2）被切片。

也可以通过直接向ndarray对象提供以冒号 : 分隔的切片参数 (start:stop:step) 来获得相同的结果。

示例 2

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

这里，我们将获得相同的输出：

[2  4  6]

如果只输入一个参数，则将返回与索引对应的单个项目。如果在前面插入一个 :，则将提取从该索引开始的所有项目。如果使用两个参数（它们之间用 : 分隔），则将切片两个索引之间的项目（不包括 stop 索引），默认步长为 1。

示例 3

# slice single item 
import numpy as np 

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

其输出如下所示：

5

示例 4

# slice items starting from index 
import numpy as np 
a = np.arange(10) 
print a[2:]

现在，输出将为：

[2  3  4  5  6  7  8  9]

示例 5

# slice items between indexes 
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  

# slice items starting from index
print 'Now we will slice the array from the index a[1:]' 
print a[1:]

输出如下：

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

Now we will slice the array from the index a[1:]
[[3 4 5]
 [4 5 6]]

切片还可以包含省略号 (…) 以创建与数组维度相同长度的选择元组。如果在行位置使用省略号，它将返回一个包含行中项目的 ndarray。

示例 7

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

print 'Our array is:' 
print a 
print '\n'  

# this returns array of items in the second column 
print 'The items in the second column are:'  
print a[...,1] 
print '\n'  

# Now we will slice all items from the second row 
print 'The items in the second row are:' 
print a[1,...] 
print '\n'  

# Now we will slice all items from column 1 onwards 
print 'The items column 1 onwards are:' 
print a[...,1:]

此程序的输出如下所示：

Our array is:
[[1 2 3]
 [3 4 5]
 [4 5 6]] 
 
The items in the second column are: 
[2 4 5] 

The items in the second row are:
[3 4 5]

The items column 1 onwards are:
[[2 3]
 [4 5]
 [5 6]] 

NumPy - 高级索引

可以从 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 'Our array is:' 
print x 
print '\n' 

rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols] 
   
print 'The corner elements of this array are:' 
print y

此程序的输出如下所示：

Our array is:                                                                 
[[ 0  1  2]                                                                   
 [ 3  4  5]                                                                   
 [ 6  7  8]                                                                   
 [ 9 10 11]]
 
The corner elements of this array are:                                        
[[ 0  2]                                                                      
 [ 9 11]] 

结果选择是一个包含角元素的 ndarray 对象。

高级索引和基本索引可以通过使用一个切片 (:) 或省略号 (…) 与索引数组结合使用。以下示例对行使用切片，对列使用高级索引。当对两者都使用切片时，结果相同。但高级索引会导致复制，并且可能具有不同的内存布局。

示例 3

import numpy as np 
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) 

print 'Our array is:' 
print x 
print '\n'  

# slicing 
z = x[1:4,1:3] 

print 'After slicing, our array becomes:' 
print z 
print '\n'  

# using advanced index for column 
y = x[1:4,[1,2]] 

print 'Slicing using advanced index for column:' 
print y

此程序的输出将如下所示：

Our array is:
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8]
 [ 9 10 11]]
 
After slicing, our array becomes:
[[ 4  5]
 [ 7  8]
 [10 11]]

Slicing using advanced index for column:
[[ 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 'Our array is:' 
print x 
print '\n'  

# Now we will print the items greater than 5 
print 'The items greater than 5 are:' 
print x[x > 5]

此程序的输出将为：

Our array is: 
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8] 
 [ 9 10 11]] 
 
The items greater than 5 are:
[ 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 - 广播

术语广播（broadcasting）指的是 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，则该维度中的第一个数据条目将用于沿该维度进行的所有计算。

如果上述规则产生有效结果，并且以下条件之一为真，则一组数组被称为可广播（broadcastable）：

• 数组具有完全相同的形状。

• 数组具有相同的维度数，并且每个维度的长度要么是公共长度，要么是 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 'First array:' 
print a 
print '\n'  
   
print 'Second array:' 
print b 
print '\n'  
   
print 'First Array + Second Array' 
print a + b

此程序的输出将如下所示：

First array:
[[ 0. 0. 0.]
 [ 10. 10. 10.]
 [ 20. 20. 20.]
 [ 30. 30. 30.]]

Second array:
[ 1. 2. 3.]

First Array + Second Array
[[ 1. 2. 3.]
 [ 11. 12. 13.]
 [ 21. 22. 23.]
 [ 31. 32. 33.]]

下图演示了数组b如何被广播以使其与a兼容。

NumPy - 遍历数组

NumPy 包含一个迭代器对象numpy.nditer。它是一个高效的多维迭代器对象，可以使用它来迭代数组。使用 Python 的标准迭代器接口访问数组的每个元素。

让我们使用 arange() 函数创建一个 3X4 数组，并使用nditer对其进行迭代。

示例 1

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)

print 'Original array is:'
print a
print '\n'

print 'Modified array is:'
for x in np.nditer(a):
   print x,

此程序的输出如下所示：

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Modified array is:
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 'Original array is:'
print a 
print '\n'  
   
print 'Transpose of the original array is:' 
b = a.T 
print b 
print '\n'  
   
print 'Modified array is:' 
for x in np.nditer(b): 
   print x,

上述程序的输出如下：

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Transpose of the original array is:
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

Modified array is:
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 'Original array is:'
print a
print '\n'

print 'Transpose of the original array is:'
b = a.T
print b
print '\n'

print 'Sorted in C-style order:'
c = b.copy(order='C')
print c
for x in np.nditer(c):
   print x,

print '\n'

print 'Sorted in F-style order:'
c = b.copy(order='F')
print c
for x in np.nditer(c):
   print x,

其输出将如下所示：

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Transpose of the original array is:
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

Sorted in C-style order:
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55

Sorted in F-style order:
[[ 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 'Original array is:' 
print a 
print '\n'  

print 'Sorted in C-style order:' 
for x in np.nditer(a, order = 'C'): 
   print x,  
print '\n' 

print 'Sorted in F-style order:' 
for x in np.nditer(a, order = 'F'): 
   print x,

其输出将为：

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Sorted in C-style order:
0 5 10 15 20 25 30 35 40 45 50 55

Sorted in F-style order:
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 'Original array is:'
print a
print '\n'

for x in np.nditer(a, op_flags = ['readwrite']):
   x[...] = 2*x
print 'Modified array is:'
print a

其输出如下所示：

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Modified array is:
[[ 0 10 20 30]
 [ 40 50 60 70]
 [ 80 90 100 110]]

外部循环

nditer 类构造函数有一个'flags'参数，它可以取以下值：

示例

在下面的示例中，迭代器遍历对应于每一列的一维数组。

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4) 

print 'Original array is:' 
print a 
print '\n'  

print 'Modified array is:' 
for x in np.nditer(a, flags = ['external_loop'], order = 'F'): 
   print x,

输出如下：

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Modified array is:
[ 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 'First array is:' 
print a 
print '\n'  

print 'Second array is:' 
b = np.array([1, 2, 3, 4], dtype = int) 
print b  
print '\n' 

print 'Modified array is:' 
for x,y in np.nditer([a,b]): 
   print "%d:%d" % (x,y),

其输出将如下所示：

First array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Second array is:
[1 2 3 4]

Modified array is:
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 对象中元素的例程。它们可以分为以下类型：

更改形状

转置操作

更改维度

连接数组

分割数组

添加/删除元素

NumPy - 二元运算符

以下是 NumPy 包中可用的按位运算函数。

NumPy - 字符串函数

以下函数用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行矢量化字符串操作。它们基于 Python 内置库中标准的字符串函数。

这些函数在字符数组类 (numpy.char) 中定义。旧的 Numarray 包包含 chararray 类。numpy.char 类中的上述函数对于执行矢量化字符串操作很有用。

NumPy - 数学函数

可以理解的是，NumPy 包含大量各种数学运算。NumPy 提供标准三角函数、算术运算函数、复数处理等。

三角函数

NumPy 具有标准三角函数，这些函数返回给定以弧度表示的角度的三角比。

示例

import numpy as np 
a = np.array([0,30,45,60,90]) 

print 'Sine of different angles:' 
# Convert to radians by multiplying with pi/180 
print np.sin(a*np.pi/180) 
print '\n'  

print 'Cosine values for angles in array:' 
print np.cos(a*np.pi/180) 
print '\n'  

print 'Tangent values for given angles:' 
print np.tan(a*np.pi/180) 

这是它的输出：

Sine of different angles:                                                     
[ 0.          0.5         0.70710678  0.8660254   1.        ]

Cosine values for angles in array:
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01
   6.12323400e-17]

Tangent values for given angles:                                              
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00
   1.63312394e+16]

arcsin、arcos 和arctan 函数返回给定角度的 sin、cos 和 tan 的三角反函数。可以通过numpy.degrees() 函数将弧度转换为度数来验证这些函数的结果。

示例

import numpy as np 
a = np.array([0,30,45,60,90]) 

print 'Array containing sine values:' 
sin = np.sin(a*np.pi/180) 
print sin 
print '\n'  

print 'Compute sine inverse of angles. Returned values are in radians.' 
inv = np.arcsin(sin) 
print inv 
print '\n'  

print 'Check result by converting to degrees:' 
print np.degrees(inv) 
print '\n'  

print 'arccos and arctan functions behave similarly:' 
cos = np.cos(a*np.pi/180) 
print cos 
print '\n'  

print 'Inverse of cos:' 
inv = np.arccos(cos) 
print inv 
print '\n'  

print 'In degrees:' 
print np.degrees(inv) 
print '\n'  

print 'Tan function:' 
tan = np.tan(a*np.pi/180) 
print tan
print '\n'  

print 'Inverse of tan:' 
inv = np.arctan(tan) 
print inv 
print '\n'  

print 'In degrees:' 
print np.degrees(inv) 

其输出如下所示：

Array containing sine values:
[ 0.          0.5         0.70710678  0.8660254   1.        ]

Compute sine inverse of angles. Returned values are in radians.
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633] 

Check result by converting to degrees:
[  0.  30.  45.  60.  90.]

arccos and arctan functions behave similarly:
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
   6.12323400e-17] 

Inverse of cos:
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633] 

In degrees:
[  0.  30.  45.  60.  90.] 

Tan function:
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
   1.63312394e+16]

Inverse of tan:
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]

In degrees:
[  0.  30.  45.  60.  90.]

舍入函数

numpy.around()

这是一个返回舍入到所需精度的值的函数。该函数采用以下参数。

numpy.around(a,decimals)

其中，

示例

import numpy as np 
a = np.array([1.0,5.55, 123, 0.567, 25.532]) 

print 'Original array:' 
print a 
print '\n'  

print 'After rounding:' 
print np.around(a) 
print np.around(a, decimals = 1) 
print np.around(a, decimals = -1)

它产生以下输出：

Original array:                                                               
[   1.       5.55   123.       0.567   25.532] 

After rounding:                                                               
[   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 'The given array:' 
print a 
print '\n'  

print 'The modified array:' 
print np.floor(a)

它产生以下输出：

The given array:                                                              
[ -1.7   1.5  -0.2   0.6  10. ]

The modified array:                                                           
[ -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 'The given array:' 
print a 
print '\n'  

print 'The modified array:' 
print np.ceil(a)

它将产生以下输出：

The given array:                                                              
[ -1.7   1.5  -0.2   0.6  10. ]

The modified array:                                                           
[ -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 'First array:' 
print a 
print '\n'  

print 'Second array:' 
b = np.array([10,10,10]) 
print b 
print '\n'  

print 'Add the two arrays:' 
print np.add(a,b) 
print '\n'  

print 'Subtract the two arrays:' 
print np.subtract(a,b) 
print '\n'  

print 'Multiply the two arrays:' 
print np.multiply(a,b) 
print '\n'  

print 'Divide the two arrays:' 
print np.divide(a,b)

它将产生以下输出：

First array:
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

Second array:
[10 10 10]

Add the two arrays:
[[ 10. 11. 12.]
 [ 13. 14. 15.]
 [ 16. 17. 18.]]

Subtract the two arrays:
[[-10. -9. -8.]
 [ -7. -6. -5.]
 [ -4. -3. -2.]]

Multiply the two arrays:
[[ 0. 10. 20.]
 [ 30. 40. 50.]
 [ 60. 70. 80.]]

Divide the two arrays:
[[ 0. 0.1 0.2]
 [ 0.3 0.4 0.5]
 [ 0.6 0.7 0.8]]

现在让我们讨论 NumPy 中提供的一些其他重要的算术函数。

numpy.reciprocal()

此函数返回参数的倒数，元素级。对于绝对值大于 1 的元素，结果始终为 0，因为 Python 处理整数除法的方式。对于整数 0，会发出溢出警告。

示例

import numpy as np 
a = np.array([0.25, 1.33, 1, 0, 100]) 

print 'Our array is:' 
print a 
print '\n'  

print 'After applying reciprocal function:' 
print np.reciprocal(a) 
print '\n'  

b = np.array([100], dtype = int) 
print 'The second array is:' 
print b 
print '\n'  

print 'After applying reciprocal function:' 
print np.reciprocal(b) 

它将产生以下输出：

Our array is:                                                                 
[   0.25    1.33    1.      0.    100.  ]

After applying reciprocal function:                                           
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal
  print np.reciprocal(a)
[ 4.         0.7518797  1.               inf  0.01     ]

The second array is:
[100]

After applying reciprocal function:
[0]

numpy.power()

此函数将第一个输入数组中的元素视为底数，并将其提升到第二个输入数组中对应元素的幂。

import numpy as np 
a = np.array([10,100,1000]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying power function:' 
print np.power(a,2) 
print '\n'  

print 'Second array:' 
b = np.array([1,2,3]) 
print b 
print '\n'  

print 'Applying power function again:' 
print np.power(a,b)

它将产生以下输出：

Our array is:                                                                 
[  10  100 1000]

Applying power function:
[    100   10000 1000000]

Second array:
[1 2 3]

Applying power function again:
[        10      10000 1000000000]

numpy.mod()

此函数返回输入数组中对应元素的除法余数。函数numpy.remainder()也产生相同的结果。

import numpy as np 
a = np.array([10,20,30]) 
b = np.array([3,5,7]) 

print 'First array:' 
print a 
print '\n'  

print 'Second array:' 
print b 
print '\n'  

print 'Applying mod() function:' 
print np.mod(a,b) 
print '\n'  

print 'Applying remainder() function:' 
print np.remainder(a,b) 

它将产生以下输出：

First array:                                                                  
[10 20 30]

Second array:                                                                 
[3 5 7]

Applying mod() function:                                                      
[1 0 2]

Applying remainder() function:                                                
[1 0 2]

以下函数用于对具有复数的数组执行运算。

• numpy.real() - 返回复数类型参数的实部。

• numpy.imag() − 返回复数数据类型参数的虚部。

• numpy.conj() − 返回复共轭，它是通过改变虚部的符号获得的。

• numpy.angle() − 返回复数参数的角度。该函数具有degree参数。如果为真，则返回度数的角度，否则角度为弧度。

import numpy as np 
a = np.array([-5.6j, 0.2j, 11. , 1+1j]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying real() function:' 
print np.real(a) 
print '\n'  

print 'Applying imag() function:' 
print np.imag(a) 
print '\n'  

print 'Applying conj() function:' 
print np.conj(a) 
print '\n'  

print 'Applying angle() function:' 
print np.angle(a) 
print '\n'  

print 'Applying angle() function again (result in degrees)' 
print np.angle(a, deg = True)

它将产生以下输出：

Our array is:
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]

Applying real() function:
[ 0. 0. 11. 1.]

Applying imag() function:
[-5.6 0.2 0. 1. ]

Applying conj() function:
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]

Applying angle() function:
[-1.57079633 1.57079633 0. 0.78539816]

Applying angle() function again (result in degrees)
[-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 'Our array is:' 
print a  
print '\n'  

print 'Applying amin() function:' 
print np.amin(a,1) 
print '\n'  

print 'Applying amin() function again:' 
print np.amin(a,0) 
print '\n'  

print 'Applying amax() function:' 
print np.amax(a) 
print '\n'  

print 'Applying amax() function again:' 
print np.amax(a, axis = 0)

它将产生以下输出：

Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]

Applying amin() function:
[3 3 2]

Applying amin() function again:
[2 4 3]

Applying amax() function:
9

Applying amax() function again:
[8 7 9]

numpy.ptp()

numpy.ptp() 函数返回沿某个轴的值的范围（最大值-最小值）。

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

print 'Our array is:' 
print a 
print '\n'  

print 'Applying ptp() function:' 
print np.ptp(a) 
print '\n'  

print 'Applying ptp() function along axis 1:' 
print np.ptp(a, axis = 1) 
print '\n'   

print 'Applying ptp() function along axis 0:'
print np.ptp(a, axis = 0) 

它将产生以下输出：

Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]

Applying ptp() function:
7

Applying ptp() function along axis 1:
[4 5 7]

Applying ptp() function along axis 0:
[6 3 6]

numpy.percentile()

百分位数（或百分位数）是统计学中使用的一种度量，表示一组观测值中低于给定百分比的观测值的数值。numpy.percentile() 函数接受以下参数。

numpy.percentile(a, q, axis)

其中，

示例

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying percentile() function:' 
print np.percentile(a,50) 
print '\n'  

print 'Applying percentile() function along axis 1:' 
print np.percentile(a,50, axis = 1) 
print '\n'  

print 'Applying percentile() function along axis 0:' 
print np.percentile(a,50, axis = 0)

它将产生以下输出：

Our array is:
[[30 40 70]
 [80 20 10]
 [50 90 60]]

Applying percentile() function:
50.0

Applying percentile() function along axis 1:
[ 40. 20. 60.]

Applying percentile() function along axis 0:
[ 50. 40. 60.]

numpy.median()

中位数定义为将数据样本的上半部分与下半部分分隔的值。numpy.median() 函数的使用方法如下面的程序所示。

示例

import numpy as np 
a = np.array([[30,65,70],[80,95,10],[50,90,60]]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying median() function:' 
print np.median(a) 
print '\n'  

print 'Applying median() function along axis 0:' 
print np.median(a, axis = 0) 
print '\n'  
 
print 'Applying median() function along axis 1:' 
print np.median(a, axis = 1)

它将产生以下输出：

Our array is:
[[30 65 70]
 [80 95 10]
 [50 90 60]]

Applying median() function:
65.0

Applying median() function along axis 0:
[ 50. 90. 60.]

Applying median() function along axis 1:
[ 65. 80. 60.]

numpy.mean()

算术平均值是沿某个轴的元素之和除以元素的数量。numpy.mean() 函数返回数组中元素的算术平均值。如果指定了轴，则沿该轴计算。

示例

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

print 'Our array is:' 
print a 
print '\n'  

print 'Applying mean() function:' 
print np.mean(a) 
print '\n'  

print 'Applying mean() function along axis 0:' 
print np.mean(a, axis = 0) 
print '\n'  

print 'Applying mean() function along axis 1:' 
print np.mean(a, axis = 1)

它将产生以下输出：

Our array is:
[[1 2 3]
 [3 4 5]
 [4 5 6]]

Applying mean() function:
3.66666666667

Applying mean() function along axis 0:
[ 2.66666667 3.66666667 4.66666667]

Applying mean() function along axis 1:
[ 2. 4. 5.]

numpy.average()

加权平均值是指每个分量乘以一个反映其重要性的因子而得到的平均值。numpy.average() 函数根据另一个数组中给定的相应权重计算数组中元素的加权平均值。该函数可以具有 axis 参数。如果未指定轴，则数组会被展平。

考虑一个数组 [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 'Our array is:' 
print a 
print '\n'  

print 'Applying average() function:' 
print np.average(a) 
print '\n'  

# this is same as mean when weight is not specified 
wts = np.array([4,3,2,1]) 

print 'Applying average() function again:' 
print np.average(a,weights = wts) 
print '\n'  

# Returns the sum of weights, if the returned parameter is set to True. 
print 'Sum of weights' 
print np.average([1,2,3, 4],weights = [4,3,2,1], returned = True)

它将产生以下输出：

Our array is:
[1 2 3 4]

Applying average() function:
2.5

Applying average() function again:
2.0

Sum of weights
(2.0, 10.0)

在多维数组中，可以指定计算的轴。

示例

import numpy as np 
a = np.arange(6).reshape(3,2) 

print 'Our array is:' 
print a 
print '\n'  

print 'Modified array:' 
wt = np.array([3,5]) 
print np.average(a, axis = 1, weights = wt) 
print '\n'  

print 'Modified array:' 
print np.average(a, axis = 1, weights = wt, returned = True)

它将产生以下输出：

Our array is:
[[0 1]
 [2 3]
 [4 5]]

Modified array:
[ 0.625 2.625 4.625]

Modified array:
(array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))

标准差

标准差是平均值的平方偏差的平均值的平方根。标准差的公式如下：

std = sqrt(mean(abs(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(abs(x - x.mean())**2)。换句话说，标准差是方差的平方根。

示例

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

它将产生以下输出：

1.25

NumPy - 排序、搜索和计数函数

NumPy 中提供了各种与排序相关的函数。这些排序函数实现了不同的排序算法，每个算法都以执行速度、最坏情况性能、所需工作空间和算法的稳定性为特征。下表显示了三种排序算法的比较。

numpy.sort()

sort() 函数返回输入数组的已排序副本。它具有以下参数：

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

其中，

示例

import numpy as np  
a = np.array([[3,7],[9,1]]) 

print 'Our array is:' 
print a 
print '\n'

print 'Applying sort() function:' 
print np.sort(a) 
print '\n' 
  
print 'Sort along axis 0:' 
print np.sort(a, axis = 0) 
print '\n'  

# Order parameter in sort function 
dt = np.dtype([('name', 'S10'),('age', int)]) 
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt) 

print 'Our array is:' 
print a 
print '\n'  

print 'Order by name:' 
print np.sort(a, order = 'name')

它将产生以下输出：

Our array is:
[[3 7]
 [9 1]]

Applying sort() function:
[[3 7]
 [1 9]]

Sort along axis 0:
[[3 1]
 [9 7]]

Our array is:
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]

Order by name:
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]

numpy.argsort()

numpy.argsort() 函数对输入数组进行间接排序，沿给定的轴并使用指定的排序类型返回数据索引数组。此索引数组用于构造已排序的数组。

示例

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

print 'Our array is:' 
print x 
print '\n'  

print 'Applying argsort() to x:' 
y = np.argsort(x) 
print y 
print '\n'  

print 'Reconstruct original array in sorted order:' 
print x[y] 
print '\n'  

print 'Reconstruct the original array using loop:' 
for i in y: 
   print x[i],

它将产生以下输出：

Our array is:
[3 1 2]

Applying argsort() to x:
[1 2 0]

Reconstruct original array in sorted order:
[1 2 3]

Reconstruct the original array using loop:
1 2 3

numpy.lexsort()

函数使用一系列键执行间接排序。键可以看作电子表格中的列。该函数返回一个索引数组，使用该数组可以获得已排序的数据。请注意，最后一个键恰好是排序的主键。

示例

import numpy as np 

nm = ('raju','anil','ravi','amar') 
dv = ('f.y.', 's.y.', 's.y.', 'f.y.') 
ind = np.lexsort((dv,nm)) 

print 'Applying lexsort() function:' 
print ind 
print '\n'  

print 'Use this index to get sorted data:' 
print [nm[i] + ", " + dv[i] for i in ind] 

它将产生以下输出：

Applying lexsort() function:
[3 1 0 2]

Use this index to get sorted data:
['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 'Our array is:' 
print a 
print '\n' 

print 'Applying argmax() function:' 
print np.argmax(a) 
print '\n'  

print 'Index of maximum number in flattened array' 
print a.flatten() 
print '\n'  

print 'Array containing indices of maximum along axis 0:' 
maxindex = np.argmax(a, axis = 0) 
print maxindex 
print '\n'  

print 'Array containing indices of maximum along axis 1:' 
maxindex = np.argmax(a, axis = 1) 
print maxindex 
print '\n'  

print 'Applying argmin() function:' 
minindex = np.argmin(a) 
print minindex 
print '\n'  
   
print 'Flattened array:' 
print a.flatten()[minindex] 
print '\n'  

print 'Flattened array along axis 0:' 
minindex = np.argmin(a, axis = 0) 
print minindex
print '\n'

print 'Flattened array along axis 1:' 
minindex = np.argmin(a, axis = 1) 
print minindex

它将产生以下输出：

Our array is:
[[30 40 70]
 [80 20 10]
 [50 90 60]]

Applying argmax() function:
7

Index of maximum number in flattened array
[30 40 70 80 20 10 50 90 60]

Array containing indices of maximum along axis 0:
[1 2 0]

Array containing indices of maximum along axis 1:
[2 0 1]

Applying argmin() function:
5

Flattened array:
10

Flattened array along axis 0:
[0 1 1]

Flattened array along axis 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 'Our array is:' 
print a 
print '\n'  

print 'Applying nonzero() function:' 
print np.nonzero (a)

它将产生以下输出：

Our array is:
[[30 40 0]
 [ 0 20 10]
 [50 0 60]]

Applying nonzero() function:
(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 'Our array is:' 
print x  

print 'Indices of elements > 3' 
y = np.where(x > 3) 
print y  

print 'Use these indices to get elements satisfying the condition' 
print x[y]

它将产生以下输出：

Our array is:
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

Indices of elements > 3
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

Use these indices to get elements satisfying the condition
[ 4. 5. 6. 7. 8.]

numpy.extract()

extract() 函数返回满足任何条件的元素。

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

print 'Our array is:' 
print x  

# define a condition 
condition = np.mod(x,2) == 0 

print 'Element-wise value of condition' 
print condition  

print 'Extract elements using condition' 
print np.extract(condition, x)

它将产生以下输出：

Our array is:
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

Element-wise value of condition
[[ True False True]
 [False True False]
 [ True False True]]

Extract elements using condition
[ 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 'Our array is:' 
print a  

print 'Representation of data in memory in hexadecimal form:'  
print map(hex,a)  
# byteswap() function swaps in place by passing True parameter 

print 'Applying byteswap() function:' 
print a.byteswap(True) 

print 'In hexadecimal form:' 
print map(hex,a) 
# We can see the bytes being swapped

它将产生以下输出：

Our array is:
[1 256 8755]

Representation of data in memory in hexadecimal form:
['0x1', '0x100', '0x2233']

Applying byteswap() function:
[256 1 13090]

In hexadecimal form:
['0x100', '0x1', '0x3322']

NumPy - 副本和视图

在执行函数时，其中一些函数返回输入数组的副本，而另一些函数返回视图。当内容在物理上存储在另一个位置时，称为副本。另一方面，如果提供了相同内存内容的不同视图，我们将其称为视图。

无副本

简单的赋值不会创建数组对象的副本。相反，它使用原始数组的相同 id() 来访问它。id() 返回 Python 对象的通用标识符，类似于 C 中的指针。

此外，任何一个的更改都会反映在另一个中。例如，一个的形状更改也会更改另一个的形状。

示例

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

print 'Our array is:' 
print a  

print 'Applying id() function:' 
print id(a)  

print 'a is assigned to b:' 
b = a 
print b  

print 'b has same id():' 
print id(b)  

print 'Change shape of b:' 
b.shape = 3,2 
print b  

print 'Shape of a also gets changed:' 
print a

它将产生以下输出：

Our array is:
[0 1 2 3 4 5]

Applying id() function:
139747815479536

a is assigned to b:
[0 1 2 3 4 5]
b has same id():
139747815479536

Change shape of b:
[[0 1]
 [2 3]
 [4 5]]

Shape of a also gets changed:
[[0 1]
 [2 3]
 [4 5]]

视图或浅拷贝

NumPy 具有ndarray.view() 方法，该方法是一个新的数组对象，它查看原始数组的相同数据。与前面的情况不同，新数组的维数更改不会更改原始数组的维数。

示例

import numpy as np 
# To begin with, a is 3X2 array 
a = np.arange(6).reshape(3,2) 

print 'Array a:' 
print a  

print 'Create view of a:' 
b = a.view() 
print b  

print 'id() for both the arrays are different:' 
print 'id() of a:'
print id(a)  
print 'id() of b:' 
print id(b)  

# Change the shape of b. It does not change the shape of a 
b.shape = 2,3 

print 'Shape of b:' 
print b  

print 'Shape of a:' 
print a

它将产生以下输出：

Array a:
[[0 1]
 [2 3]
 [4 5]]

Create view of a:
[[0 1]
 [2 3]
 [4 5]]

id() for both the arrays are different:
id() of a:
140424307227264
id() of b:
140424151696288

Shape of b:
[[0 1 2]
 [3 4 5]]

Shape of a:
[[0 1]
 [2 3]
 [4 5]]

数组的切片会创建一个视图。

示例

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

print 'Our array is:' 
print a  

print 'Create a slice:' 
s = a[:, :2] 
print s 

它将产生以下输出：

Our array is:
[[10 10]
 [ 2 3]
 [ 4 5]]

Create a slice:
[[10 10]
 [ 2 3]
 [ 4 5]]

深拷贝

ndarray.copy() 函数创建一个深拷贝。它是数组及其数据的完整副本，并且不与原始数组共享。

示例

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

print 'Array a is:' 
print a  

print 'Create a deep copy of a:' 
b = a.copy() 
print 'Array b is:' 
print b 

#b does not share any memory of a 
print 'Can we write b is a' 
print b is a  

print 'Change the contents of b:' 
b[0,0] = 100 

print 'Modified array b:' 
print b  

print 'a remains unchanged:' 
print a

它将产生以下输出：

Array a is:
[[10 10]
 [ 2 3]
 [ 4 5]]

Create a deep copy of a:
Array b is:
[[10 10]
 [ 2 3]
 [ 4 5]]
Can we write b is a
False

Change the contents of b:
Modified array b:
[[100 10]
 [ 2 3]
 [ 4 5]]

a remains unchanged:
[[10 10]
 [ 2 3]
 [ 4 5]]

NumPy - 矩阵库

NumPy 包含一个矩阵库numpy.matlib。此模块包含返回矩阵而不是 ndarray 对象的函数。

matlib.empty()

matlib.empty() 函数返回一个新的矩阵，但不初始化条目。该函数接受以下参数。

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

其中，

示例

import numpy.matlib 
import numpy as np 

print np.matlib.empty((2,2)) 
# filled with random data

它将产生以下输出：

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

此函数返回填充有 1 的矩阵。

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)

其中，

示例

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模块，该模块提供了线性代数所需的所有功能。下表描述了此模块中的一些重要函数。

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 库中最重要的函数，用于绘制二维数据。以下脚本绘制方程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()

从np.arange() 函数创建 ndarray 对象 x 作为x 轴上的值。y 轴上的对应值存储在另一个ndarray 对象 y中。这些值使用 matplotlib 包的 pyplot 子模块的plot()函数绘制。

图形表示由show()函数显示。

上述代码应产生以下输出：

除了线性图，还可以通过向plot()函数添加格式字符串来离散显示值。可以使用以下格式字符。

以下还定义了颜色缩写。

要显示表示点的圆圈，而不是上面示例中的线，请在 plot() 函数中使用“ob”作为格式字符串。

示例

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

上述代码应产生以下输出：

正弦波图

以下脚本使用 matplotlib 生成正弦波图。

示例

import numpy as np 
import matplotlib.pyplot as plt  

# Compute the x and y coordinates for points on a sine curve 
x = np.arange(0, 3 * np.pi, 0.1) 
y = np.sin(x) 
plt.title("sine wave form") 

# Plot the points using matplotlib 
plt.plot(x, y) 
plt.show() 

subplot()

subplot() 函数允许您在同一图形中绘制不同的内容。在以下脚本中，绘制了正弦和余弦值。

示例

import numpy as np 
import matplotlib.pyplot as plt  
   
# Compute the x and y coordinates for points on sine and cosine curves 
x = np.arange(0, 3 * np.pi, 0.1) 
y_sin = np.sin(x) 
y_cos = np.cos(x)  
   
# Set up a subplot grid that has height 2 and width 1, 
# and set the first such subplot as active. 
plt.subplot(2, 1, 1)
   
# Make the first plot 
plt.plot(x, y_sin) 
plt.title('Sine')  
   
# Set the second subplot as active, and make the second plot. 
plt.subplot(2, 1, 2) 
plt.plot(x, y_cos) 
plt.title('Cosine')  
   
# Show the figure. 
plt.show()

上述代码应产生以下输出：

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）的相等水平尺寸和对应于频率的可变高度。

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

它应该产生以下输出：

NumPy 的 I/O

ndarray 对象可以保存到磁盘文件并从磁盘文件加载。可用的 IO 函数有：

• load() 和save() 函数处理 /numPy 二进制文件（扩展名为npy）

• loadtxt() 和savetxt() 函数处理普通文本文件

NumPy 引入了一种用于 ndarray 对象的简单文件格式。此.npy文件将数据、形状、dtype 和重建 ndarray 所需的其他信息存储在磁盘文件中，以便即使文件位于具有不同体系结构的其他计算机上，也可以正确检索数组。

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()和loadtxt()函数以简单的文本文件格式存储和检索数组数据。

示例

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() 函数接受其他可选参数，例如标题、脚注和分隔符。