Numpy 简明教程

NumPy - Quick Guide

NumPy - Introduction

NumPy 是一个 Python 包，代表“Numerical Python”。它是一个包含多维数组对象和一组阵列处理例程的库。

Numeric 的祖先 NumPy 是由 Jim Hugunin 开发的。另一个软件包 Numarray 也得到了开发，具有其他一些功能。2005 年，Travis Oliphant 创建了 NumPy 包，将 Numarray 的功能合并到 Numeric 包中。许多贡献者参与了这个开源项目。

Operations using NumPy

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

  1. 数组上的数学和逻辑运算。

  2. 形状操纵的傅里叶变换和例程。

  3. 与线性代数相关的操作。NumPy 具有用于线性代数和随机数生成的内置函数。

NumPy – A Replacement for MatLab

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

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

NumPy - Environment

标准 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)：它是一个针对 Windows 操作系统的、拥有 SciPy 堆栈和 Spyder IDE 的免费 Python 分发版。（可从 https://www.python-xy.github.io/ 下载）

Linux

各个 Linux 发行版的包管理器用于安装 SciPy 堆栈中的一个或多个包。

For Ubuntu

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

For Fedora

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

Building from Source

必须安装带有 distutils 的核心 Python（2.6.x、2.7.x 和 3.2.x 及更高版本），并且应启用 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 Object

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

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

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

ndarray

在之后教程中所述的不同数组创建例程中，可以构造 ndarray 类的实例。使用 NumPy 中的数组函数按如下方式创建基本 ndarray：

numpy.array

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

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

上述构造函数接受以下参数：

Sr.No.

Parameter & Description

1

object 公开数组接口方法的任何对象都会返回一个数组或任何（嵌套的）序列。

2

dtype 数组的期望数据类型，可选

3

copy 可选的。默认情况下（true），拷贝该对象

4

order C （行优先）或 F （列优先）或 A （随便的） (默认)

5

subok 默认情况下，返回的数组被强制为基类数组。如果为真，则子类通过

6

ndmin 指定所得数组的最小尺寸

仔细查看以下示例，以便更好地理解。

Example 1

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

输出如下 −

[1, 2, 3]

Example 2

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

输出如下 −

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

Example 3

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

输出如下 −

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

Example 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 - Data Types

NumPy 支持的数值类型比 Python 所支持的类型多得多。下表显示了 NumPy 中定义的不同标量数据类型。

Sr.No.

Data Types & Description

1

bool_ 以字节形式存储的是布尔值（真或假）

2

int_ 默认整数类型（与 C long 相同；通常是 int64 或 int32）

3

intc 与 C int 相同（通常是 int32 或 int64）

4

intp 用于索引的整数（与 C ssize_t 相同；通常是 int32 或 int64）

5

int8 Byte (-128 to 127)

6

int16 Integer (-32768 to 32767)

7

int32 Integer (-2147483648 to 2147483647)

8

int64 Integer (-9223372036854775808 to 9223372036854775807)

9

uint8 无符号整数（0 到 255）

10

uint16 无符号整数（0 到 65535）

11

uint32 无符号整数（0 到 4294967295）

12

uint64 无符号整数（0 到 18446744073709551615）

13

float_ Shorthand for float64

14

float16 半精度浮点数：符号位、5 位指数、10 位尾数

15

float32 单精度浮点数：符号位、8 位指数、23 位尾数

16

float64 双精度浮点数：符号位、11 位指数、52 位尾数

17

complex_ Shorthand for complex128

18

complex64 复数，由两个 32 位浮点数（实部和虚部组成）表示

19

complex128 复数，由两个 64 位浮点数（实部和虚部组成）表示

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

Data Type Objects (dtype)

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

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

  2. Size of data

  3. 字节序（小端或大端）

  4. 如果为结构化类型，则包括字段的名称、每个字段的数据类型以及每个字段占据的内存块部分。

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

通过在数据类型前面添加'<'或'>'来确定字节顺序。'<'表示编码是小端序（最小重要位存储在最小地址）。'>'表示编码是大端序（最大重要位存储在最小地址）。

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

numpy.dtype(object, align, copy)

参数是 -

  1. Object - 转换为数据类型对象

  2. Align - 如果为真，为字段添加填充以使其类似于C结构

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

Example 1

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

输出如下 −

int32

Example 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

Example 3

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

输出如下 −

>i4

以下示例显示结构化数据类型的使用。此处，应声明字段名称和相应标量数据类型。

Example 4

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

输出如下 −

[('age', 'i1')]

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

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

Example 7

以下示例定义一个名为 student 的结构化数据类型，该数据类型具有字符串字段’name'，一个 integer field 'age’和一个 float field 'marks'。此dtype应用于ndarray对象。

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

输出如下 −

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

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

每个内置数据类型都具有唯一标识它的字符代码。

  1. 'b' − boolean

  2. 'i' − (signed) integer

  3. 'u' − unsigned integer

  4. 'f' − floating-point

  5. 'c' − complex-floating point

  6. 'm' − timedelta

  7. 'M' − datetime

  8. 'O' − (Python) objects

  9. 'S', 'a' − (byte-)string

  10. 'U' − Unicode

  11. 'V' - 原始数据（void）

NumPy - Array Attributes

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

ndarray.shape

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

Example 1

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

输出如下 −

(2, 3)

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

Example 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

此数组属性返回数组的维度数。

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

Example 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

此 array 属性以字节返回数组中每个元素的长度。

Example 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

Example 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 对象具有以下属性。其当前值由该函数返回。

Sr.No.

Attribute & Description

1

C_CONTIGUOUS &#169; 数据位于单一的 C 风格连续段中

2

F_CONTIGUOUS (F) 数据位于单一的 Fortran 风格连续段中

3

OWNDATA (O) 数组拥有它使用的内存或从另一个对象借用内存

4

WRITEABLE (W) 可以对数据区域进行写入。将此项设置为 False 可锁定数据，使其为只读。

5

ALIGNED (A) 数据和所有元素均针对硬件进行了适当地对齐

6

UPDATEIFCOPY (U) 此数组是某个其他数组的副本。当此数组被析构时，基础数组将使用此数组的内容进行更新

Example

以下示例展示标记的当前值。

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 - Array Creation Routines

可以通过以下任何数组创建例程或使用低级 ndarray 构造函数构建一个新的 ndarray 对象。

numpy.empty

它创建一个指定形状和数据类型的未初始化数组。它使用以下构造函数 −

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

构造函数需要以下参数。

Sr.No.

Parameter & Description

1

Shape 整数或整数元组形式的空数组的形状

2

Dtype 期望的输出数据类型。可选

3

Order 对于 C 样式行优先数组为“C”，对于 FORTRAN 样式列优先数组为“F”

Example

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

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

输出如下 −

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

Note − 由于数组中的元素未初始化，所以它们显示随机值。

numpy.zeros

返回一个指定的尺寸的新数组，并用零填充。

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

构造函数需要以下参数。

Sr.No.

Parameter & Description

1

Shape 整数或整数序列形式的空数组的形状

2

Dtype 期望的输出数据类型。可选

3

Order 对于 C 样式行优先数组为“C”，对于 FORTRAN 样式列优先数组为“F”

Example 1

# array of five zeros. Default dtype is float
import numpy as np
x = np.zeros(5)
print x

输出如下 −

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

Example 2

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

现在，输出如下 −

[0  0  0  0  0]

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

构造函数需要以下参数。

Sr.No.

Parameter & Description

1

Shape 整数或整数元组形式的空数组的形状

2

Dtype 期望的输出数据类型。可选

3

Order 对于 C 样式行优先数组为“C”，对于 FORTRAN 样式列优先数组为“F”

Example 1

# array of five ones. Default dtype is float
import numpy as np
x = np.ones(5)
print x

输出如下 −

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

Example 2

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

现在，输出如下 −

[[1  1]
 [1  1]]

NumPy - Array From Existing Data

在本章中，我们将讨论如何从现有数据创建数组。

numpy.asarray

此函数与 numpy.array 类似，但参数更少。此例程可用于将 Python 序列转换为 ndarray。

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

构造函数需要以下参数。

Sr.No.

Parameter & Description

1

a 任何形式的输入数据，例如列表、元组列表、元组、元组的元组或列表的元组

2

dtype 默认情况下，将输入数据的类型应用于结果 ndarray

3

order C（行优先）或 F（列优先）。C 是默认值

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

Example 1

# convert list to ndarray
import numpy as np

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

其输出如下所示 −

[1  2  3]

Example 2

# dtype is set
import numpy as np

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

现在，输出如下 −

[ 1.  2.  3.]

Example 3

# ndarray from tuple
import numpy as np

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

其输出将为 −

[1  2  3]

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

构造函数需要以下参数。

Sr.No.

Parameter & Description

1

buffer 公开缓冲区接口的任何对象

2

dtype 返回ndarray的数据类型。默认为浮点型

3

count 要读取的项数，默认为-1，表示所有数据

4

offset 读取的起始位置。默认为0

Example

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

此处，构造函数采用以下参数。

Sr.No.

Parameter & Description

1

iterable Any iterable object

2

dtype 结果数组的数据类型

3

count 从迭代器中读取的项数。默认为-1，表示读取所有数据

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

Example 1

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

它的输出如下：

[0,  1,  2,  3,  4]

Example 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 - Array From Numerical Ranges

在本章节中，我们将会介绍如何从数值范围创建数组。

numpy.arange

此函数返回一个 ndarray 对象，其中包含给定范围内间隔均匀的值。该函数的格式如下所示 −

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

构造函数需要以下参数。

Sr.No.

Parameter & Description

1

start 一个区间开始位置。如果省略，则默认为 0

2

stop 一个区间结束位置（不包括此数字）

3

step 值之间的间隔，默认为 1

4

dtype 结果 ndarray 的数据类型。如果未给出，则使用输入的数据类型

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

Example 1

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

其输出如下所示 −

[0  1  2  3  4]

Example 2

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

在此处，输出将为 −

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

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

构造函数需要以下参数。

Sr.No.

Parameter & Description

1

start 序列的起始值

2

stop 序列的结束值，如果将 endpoint 设置为 true，则包含在序列中

3

num 要生成的均匀间隔样本的数量。默认为 50

4

endpoint 默认为 true，因此，停止值包含在序列中。如果为 false，则不包含在其中

5

retstep 如果为 true，则返回连续数字之间的样本和步

6

dtype 输出 ndarray 的数据类型

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

Example 1

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

其输出将为 −

[10.   12.5   15.   17.5  20.]

Example 2

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

输出应为 −

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

Example 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 函数的输出。

Sr.No.

Parameter & Description

1

start 序列的开始点是 basestart

2

stop 序列的结束点是 basestop

3

num 范围内的值的数量。默认值为 50

4

endpoint 如果为真，则范围内的最后一个值停止

5

base 对数空间的基数，默认值为 10

6

dtype 输出数组的数据类型。如果没有给出，它取决于其他输入参数

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

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

Example 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 - Indexing & Slicing

ndarray 对象的内容可以通过索引或切片来访问和修改，就像 Python 的内置容器对象一样。

如前所述，ndarray 对象中的项目遵循从 0 开始的索引。有三种类型的索引方法，即： field access, basic slicing 和 advanced indexing 。

基本切片是 Python 在 n 维中对基本切片概念的扩展。通过将 start, stop 和 step 参数传递给内置 slice 函数来构建 Python 切片对象。将此切片对象传给数组以提取数组的一部分。

Example 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，被切片。

还可以通过将用冒号分隔的切片参数 (:start:stop:step) 直接传递给 ndarray 对象来获得相同的结果。

Example 2

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

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

[2  4  6]

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

Example 3

# slice single item
import numpy as np

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

它的输出如下：

5

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

Example 5

# slice items between indexes
import numpy as np
a = np.arange(10)
print a[2:5]

在此处，输出将为 −

[2  3  4]

上述描述也适用于多维数组 ndarray 。

Example 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。

Example 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 - Advanced Indexing

可以从 ndarray 中进行选择，ndarray 是非元组序列、整数或布尔数据类型的 ndarray 对象，或元组，其中至少有一项是序列对象。高级索引始终返回数据的副本。与此相反，切片只呈现视图。

有两种高级索引类型： Integer 和 Boolean 。

Integer Indexing

此机制有助于根据其N维索引选择数组中的任意项。每个整数数组都表示该维度的索引数。当索引包含与目标ndarray维度一样多的整数数组时，就变得很直接。

在以下示例中，从 ndarray 对象的每行中选择指定列的一个元素。因此，行索引包含所有行号，并且列索引指定要选择的元素。

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

Example 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 对象。

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

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

Boolean Array Indexing

此类高级索引在结果对象应该是布尔运算结果（例如比较运算符）时使用。

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

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

Example 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

术语 broadcasting 指的是 NumPy 在算术运算期间处理不同形状的数组的能力。数组上的算术运算通常在对应元素上执行。如果两个数组的形状完全相同，那么这些运算就会顺畅执行。

Example 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 中仍然可以对形状不相同的数组进行运算。较小的数组会被 broadcast 为较大数组的大小，以便它们具有兼容的形状。

如果满足以下规则，广播是可能的 −

  1. 具有比另一个 ndim 小的数组在其形状中在前面添加“1”。

  2. 输出形状中每个维度的大小是该维度中输入大小的最大值。

  3. 如果输入的大小与输出大小匹配或者其值为 1，则可以在计算中使用输入。

  4. 如果输入的维度大小为 1，则该维度中的第一个数据条目将用于沿该维度进行的所有计算。

如果上述规则产生了有效的结果，并且满足以下条件之一，则一组数组被称作 broadcastable −

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

  2. 数组具有相同数量的维度，并且每个维度的长度要么是公共长度，要么是 1。

  3. 维度太少的数组可以在其形状前面添加一个长度为 1 的维度，以使上述属性为真。

以下程序展示了一个广播示例。

Example 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 兼容。

array

NumPy - Iterating Over Array

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

让我们使用 arange() 函数创建一个 3X4 数组，并使用 nditer 遍历它。

Example 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

Example 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

Iteration Order

如果使用 F 样式顺序存储相同的元素，则迭代器将选择更有效的方式在数组上进行迭代。

Example 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

Example 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

Modifying Array Values

nditer 对象有另一个称为 op_flags 的可选参数。其默认值是只读的，但可以设置为读写或只写模式。这将允许使用此迭代器修改数组元素。

Example

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

External Loop

nditer 类构造函数具有 ‘flags’ 参数，它可以采用以下值：

Sr.No.

Parameter & Description

1

c_index 可以跟踪 C 顺序索引

2

f_index Fortran_order index is tracked

3

multi-index 可以跟踪每次迭代具有一个索引的索引类型

4

external_loop 导致给定的值为具有多个值的一维数组，而不是零维数组

Example

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

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]

Broadcasting Iteration

如果两个数组是 broadcastable ，则一个合并的 nditer 对象能够同时在它们上进行迭代。假设数组 a 有 3X4 维，并且有另一个数组 b 有 1X4 维，则使用以下类型的迭代器（数组 b 被广播到 a 的大小）。

Example

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 - Array Manipulation

NumPy 包中提供了多个例程，用于处理 ndarray 对象中的元素。它们可以分类为以下类型：

Changing Shape

Sr.No.

Shape & Description

1

` reshape ` 给数组一个新形状而无需更改其数据

2

` flat ` 数组上的 1-D 迭代器

3

` flatten ` 返回折叠成一个维度的数组的副本

4

` ravel ` 返回一个连续的扁平数组

Transpose Operations

Sr.No.

Operation & Description

1

` transpose ` 置换数组的维度

2

ndarray.TSame as self.transpose()

3

` rollaxis ` 向后滚动指定轴

4

` swapaxes ` 交换数组的两个轴

Changing Dimensions

Sr.No.

Dimension & Description

1

` broadcast ` 产生模拟广播的对象

2

` broadcast_to ` 将数组广播到新形状

3

` expand_dims ` 扩展数组的形状

4

` squeeze ` 从数组形状中删除单维条目

Joining Arrays

Sr.No.

Array & Description

1

` concatenate ` 沿着现有轴连接一系列数组

2

` stack ` 沿着新轴连接一系列数组

3

` hstack ` 水平（按列）顺序堆叠数组

4

` vstack ` 垂直（按行）顺序堆叠数组

Splitting Arrays

Sr.No.

Array & Description

1

split 将数组拆分为多个子数组

2

hsplit 水平（按列）将数组拆分为多个子数组

3

vsplit 垂直（按行）将数组拆分为多个子数组

Adding / Removing Elements

Sr.No.

Element & Description

1

resize 返回一个形状为指定形状的新数组

2

append 将值附加到数组的末尾

3

insert 在给定的轴上将值插入到给定的索引之前

4

delete 返回一个新的数组，其中沿着轴删除了子数组

5

unique 查找数组的唯一元素

NumPy - Binary Operators

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

Sr.No.

Operation & Description

1

bitwise_and 计算数组元素的按位 AND 运算

2

bitwise_or 计算数组元素的按位 OR 运算

3

invertComputes bitwise NOT

4

left_shift 将二进制表示的位向左移动

5

right_shift 将二进制表示的位向右移动

NumPy - String Functions

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

Sr.No.

Function & Description

1

add() 返回两个 str 或 Unicode 数组的元素级字符串连接

2

multiply() 返回具有多个连接的字符串，元素级

3

center() 返回给定字符串的副本，元素居中在一个指定长度的字符串中

4

capitalize() 返回仅首字符大写的字符串副本

5

title() 返回字符串或 unicode 的元素大小写转换版本

6

lower() 返回包含已转换为小写的元素的数组

7

upper() 返回包含已转换为大写的元素的数组

8

split() 返回字符串中的单词列表，使用分隔符分隔符

9

splitlines() 返回元素中的行列表，根据行边界换行

10

strip() 返回删除了前导和尾随字符的副本

11

join() 返回由序列中的字符串连接形成的字符串

12

replace() 返回已将所有子字符串替换为新字符串的字符串的副本

13

decode()Calls str.decode element-wise

14

encode()Calls str.encode element-wise

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

NumPy - Mathematical Functions

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

Trigonometric Functions

NumPy 具有标准三角函数，可为给定的弧度角返回三角比率。

Example

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 函数返回给定角度的正弦、余弦和正切的反三角函数。这些函数的结果可以通过将弧度转换为度数由 numpy.degrees() function 验证。

Example

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

Functions for Rounding

numpy.around()

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

numpy.around(a,decimals)

其中，

Sr.No.

Parameter & Description

1

a Input data

2

要四舍五入的小数位数。默认为 0。如果为负值，则整数四舍五入到小数点左边的位置

Example

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

此函数返回不大于输入参数的最大整数。 scalar x 的底数是最大的 integer i ，即 i ⇐ x 。请注意，在 Python 中，舍入始终远离 0。

Example

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() 函数返回输入值的 ceiling，即 scalar x 的 ceiling 是最小的 integer i ，即 i >= x.

Example

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 - Arithmetic Operations

用于执行加法、减法、乘法和除法等算术运算的输入数组必须具有相同的形状，或者应遵守数组广播规则。

Example

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 的元素，由于 Python 处理整数除法的方式，结果始终为 0。对于整数 0，则会发出溢出警告。

Example

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]

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

  1. numpy.real() − 返回复数数据类型参数的实数部分。

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

  3. numpy.conj() − 返回复共轭，该共轭是通过更改虚数部分的符号获得的。

  4. 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 - Statistical Functions

NumPy 有相当一些有用的统计函数，用于查找数组中给定元素的最小值、最大值、百分位数标准差和方差等。函数的说明如下 −

numpy.amin() and numpy.amax()

这些函数从给定数组中的元素沿指定轴返回最小值和最大值。

Example

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)

其中，

Sr.No.

Argument & Description

1

a Input array

2

q 要计算的百分位数必须在 0-100 之间

3

axis 要计算百分位数的轴

Example

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

Median 被定义为将数据样本的上半部分与下半部分分开的 value。 numpy.median() 函数的使用如下所示。

Example

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() 函数返回数组中元素的算术平均数。如果提到了轴，则沿着该轴计算。

Example

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)

Example

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)

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

Example

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

Standard Deviation

标准差是平均平方离差的平方根。标准差的公式如下 −

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。

Example

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

它将生成如下输出：

1.1180339887498949

Variance

方差是平方偏差的平均值，即 mean(abs(x - x.mean()) * 2)*。换句话说，标准差是方差的平方根。

Example

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

它将生成如下输出：

1.25

NumPy - Sort, Search & Counting Functions

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

kind

speed

worst case

work space

stable

‘quicksort’

1

O(n^2)

0

no

‘mergesort’

2

O(n*log(n))

~n/2

yes

‘heapsort’

3

O(n*log(n))

0

no

numpy.sort()

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

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

其中，

Sr.No.

Parameter & Description

1

a Array to be sorted

2

axis 数组要沿其进行排序的轴。如果没有，则展平数组，在最后一个轴上进行排序

3

kind Default is quicksort

4

order 如果数组包含字段，则要排序的字段顺序

Example

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() 函数沿给定轴对输入数组执行间接排序，并使用指定类型的排序来返回数据索引数组。此索引数组用于构造已排序的数组。

Example

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

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

Example

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() and numpy.argmin()

这两个函数分别返回沿给定轴的最大元素和最小元素的索引。

Example

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() ` 函数返回输入数组中非零元素的索引。

Example

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() 函数返回输入数组中满足给定条件的元素的索引。

Example

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 - Byte Swapping

我们已经看到，计算机内存中存储的数据取决于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 - Copies & Views

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

No Copy

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

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

Example

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

View or Shallow Copy

NumPy具有 ndarray.view() 方法，该方法是一个新的数组对象，它查看原始数组的相同数据。与之前的案例不同，新数组尺寸的变化不会改变原始数组的尺寸。

Example

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

数组的分片创建视图。

Example

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

Deep Copy

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

Example

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 - Matrix Library

NumPy 包含一个矩阵库 numpy.matlib 。此模块具有返回矩阵（而非 ndarray 对象）的函数。

matlib.empty()

matlib.empty() 函数返回一个新矩阵，而不初始化条目。此函数使用以下参数。

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

其中，

Sr.No.

Parameter & Description

1

shape int 或 int 元组，定义新矩阵的形状

2

Dtype 可选。输出的数据类型

3

order C or F

Example

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、其他元素为 0 的矩阵。此函数使用以下参数。

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

其中，

Sr.No.

Parameter & Description

1

n 生成矩阵中的行数

2

M 列数，默认为 n

3

k Index of diagonal

4

dtype 输出的数据类型

Example

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() 函数返回一个填充了随机值的给定大小的矩阵。

Example

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

Note 矩阵始终是二维的，而 ndarray 是一个 n 维数组。这两个对象是可相互转换的。

Example

import numpy.matlib
import numpy as np

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

它将生成如下输出：

[[1  2]
 [3  4]]

Example

import numpy.matlib
import numpy as np

j = np.asarray(i)
print j

它将生成如下输出：

[[1  2]
 [3  4]]

Example

import numpy.matlib
import numpy as np

k = np.asmatrix (j)
print k

它将生成如下输出：

[[1  2]
 [3  4]]

NumPy - Linear Algebra

NumPy包包含 numpy.linalg 模块，该模块提供了线性代数所需的所有功能。此模块中的部分重要函数在以下表格中有所描述。

Sr.No.

Function & Description

1

dot 两个数组的点积

2

vdot 两个向量的点积

3

inner 两个数组的内积

4

matmul 两个数组的矩阵乘积

5

determinant 计算数组的行列式

6

solve 求解线性矩阵方程

7

inv 找出矩阵的乘法逆

NumPy - Matplotlib

Matplotlib 是 Python 的绘图库。它与 NumPy 一起使用，以提供一个作为 MatLab 的有效开源替代方案的环境。它还可与诸如 PyQt 和 wxPython 的图形工具包一起使用。

Matplotlib 模块最早是由 John D. Hunter 编写的。自 2012 年以来，Michael Droettboom 一直是其主要开发者。当前，Matplotlib ver. 1.5.1 是可用的稳定版本。该软件包既以二进制发行版形式提供，又以源代码形式在 www.matplotlib.org 上提供。

传统上，通过添加以下语句将包导入 Python 脚本：

from matplotlib import pyplot as plt

pyplot() 是 matplotlib 库中最重要函数，用于绘制 2D 数据。以下脚本绘制方程式 y = 2x + 5

Example

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() function 创建为 x axis 上的值。 y axis 上的相应值存储在另一个 ndarray object y 中。使用 matplotlib 包的 pyplot 子模块的 plot() 函数绘制这些值。

通过 show() 函数显示图形表示。

以上代码应会产生以下输出-

matplotlib demo

可以使用格式字符串将离散值添加到 plot() 函数中，来代替线性图。可以使用以下格式化字符。

Sr.No.

Character & Description

1

'-' Solid line style

2

'--' Dashed line style

3

'-.' Dash-dot line style

4

':' Dotted line style

5

'.' Point marker

6

',' Pixel marker

7

'o' Circle marker

8

'v' Triangle_down marker

9

'^' Triangle_up marker

10

'<' Triangle_left marker

11

'>' Triangle_right marker

12

'1' Tri_down marker

13

'2' Tri_up marker

14

'3' Tri_left marker

15

'4' Tri_right marker

16

's' Square marker

17

'p' Pentagon marker

18

''* Star marker

19

'h' Hexagon1 marker

20

'H' Hexagon2 marker

21

'+' Plus marker

22

'x' X marker

23

'D' Diamond marker

24

'd' Thin_diamond marker

25

*'

'* Vline marker

26

还定义了以下颜色缩写。

Character

Color

'b'

Blue

'g'

Green

'r'

Red

'c'

Cyan

'm'

Magenta

'y'

Yellow

'k'

Black

'w'

White

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

Example

import numpy as np
from matplotlib import pyplot as plt

x = np.arange(1,11)
y = 2 * x + 5
plt.title("Matplotlib demo")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x,y,"ob")
plt.show()

以上代码应会产生以下输出-

color abbreviation

Sine Wave Plot

以下脚本使用 matplotlib 生成 sine wave plot 。

Example

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

subplot()

subplot() 函数允许您在同一张图中绘制不同的内容。在以下脚本中，绘制的是 sine 和 cosine values 。

Example

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

以上代码应会产生以下输出-

sub plot

bar()

pyplot submodule 提供 bar() 函数来生成条形图。以下示例生成两个组的 x 和 y 数组的条形图。

Example

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

此代码应产生以下输出-

bar graph

NumPy - Histogram Using Matplotlib

NumPy 有一个 numpy.histogram() 函数，它是数据频率分布的图形表示。称为 bin 的类区间对应的水平大小相等的矩形和对应频率的 variable height 。

numpy.histogram()

numpy.histogram() 函数以输入数组和箱作为两个参数。箱数组中的连续元素作为每个箱的边界。

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() function 以包含数据和箱数组的数组作为参数，并将其转换为直方图。

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

I/O with NumPy

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

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

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

Example

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