感谢您的光临! Learnfk在线教程网正在翻译编辑中,请您稍等(v^_^)v Learnfk在线教程网
英文链接源链接 [4884]
contenteditable="true"

NumPy - Quick Guide 介绍

NumPy是一个Python包。它代表"数字Python"。它是一个由多维数组 Object 和用于处理数组的例程集合组成的库。

Numeric 是NumPy的祖先,由Jim Hugunin开发。还开发了另一个具有一些附加功能的软件包Numarray。 2005年,Travis Oliphant通过将Numarray的功能整合到Numeric包中创建了NumPy包。这个开源项目有很多贡献者。

使用NumPy的操作

使用NumPy,开发人员可以执行以下操作-

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

  • 傅里叶变换和用于形状处理的例程。

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

NumPy – MatLab的替代品

NumPy通常与 SciPy (科学Python)和 Mat-plotlib (绘图库)等软件包一起使用。这种组合被广泛地替代了MatLab,后者是技术计算的流行平台。但是,现在可以将Python替代MatLab视为一种更现代,更完善的编程语言。

它是开源的,这是NumPy的另一个优势。

NumPy模块未捆绑标准Python发行版。一种轻巧的替代方法是使用流行的Python软件包安装程序 pip 安装NumPy。

pip install numpy

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

视窗

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

Canopy (https://www.enthought.com/products/canopy/) is available as free as well as commercial distribution with full SciPy stack for 视窗, Linux and Mac.

Python (x,y): It is a free Python distribution with SciPy stack and Spyder IDE for 视窗 OS. (Downloadable from 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

从源头建造

必须使用distutils安装Core 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中定义的最重要的 Object 是称为 ndarray 的N维数组类型。它描述了相同类型的项目的集合。可以使用从零开始的索引来访问集合中的项目。

ndarray中的每一项都占用相同大小的内存块。 ndarray中的每个元素都是数据类型 Object (称为 dtype )的 Object 。

从ndarray Object 提取(通过切片)的任何项都由数组标量类型之一的Python Object 表示。下图显示了ndarray,数据类型 Object (dtype)和数组标量类型之间的关系-

Ndarray

ndarray类的实例可以通过本教程后面介绍的不同的数组创建例程来构造。基本ndarray使用NumPy中的数组函数创建,如下所示-

numpy.array 

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

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

上面的构造函数采用以下参数-

Sr.No.Parameter & Description
1

Object

任何公开数组接口方法的 Object 都将返回一个数组或任何(嵌套的)序列。

2

dtype

数组的所需数据类型,可选

3

复制

可选的。默认情况下(true),复制 Object

4

顺序的

C(行主要)或F(柱主要)或A(有)(默认值)

5

试试

默认情况下,返回的数组强制为基类数组。如果为true,则子类通过

6

ndmin

指定输出数组的最小尺寸

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

例子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 Object 由计算机内存的连续一维段组成,并带有将每个项目映射到内存块中某个位置的索引方案。内存块按行优先顺序(C样式)或列优先顺序(FORTRAN或MatLab样式)保存元素。

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

Sr.No.Data Types & Description
1

bool _

布尔值(True或False)存储为字节

2

int _

默认整数类型(与C long相同;通常为int64或int32)

3

intc

与C int相同(通常是int32或int64)

4

intp

用于索引的整数(与C ssize_t相同;通常为int32或int64)

5

int8

字节(-128至127)

6

int16

整数(-32768至32767)

7

int32

整数(-2147483648至2147483647)

8

int64

整数(-9223372036854775808至9223372036854775807)

9

uint8

无符号整数(0到255)

10

uint16

无符号整数(0到65535)

11

uint32

无符号整数(0到4294967295)

12

uint64

无符号整数(0至18446744073709551615)

13

float _

float64的简写

14

float16

半精度浮点数:符号位,5位指数,10位尾数

15

float32

单精度浮点数:符号位,8位指数,23位尾数

16

float64

双精度浮点数:符号位,11位指数,52位尾数

17

复杂_

complex128的简写

18

complex64

复数,由两个32位浮点数表示(实部和虚部)

19

complex128

复数,由两个64位浮点数表示(实部和虚部)

NumPy数值类型是dtype(数据类型) Object 的实例,每个 Object 都有独特的特征。 dtypes可作为np.bool_,np.float32等使用。

数据类型 Object (dtype)

数据类型 Object 根据以下方面描述与数组对应的固定内存块的解释-

  • 数据类型(整数,浮点数或Python Object )

  • 数据大小

  • 字节顺序(小端或大端)

  • 如果是结构化类型,则为字段名称,每个字段的数据类型以及每个字段占用的部分存储块。

  • 如果数据类型是子数组,则其形状和数据类型

The byte order is decided by prefixing '<' or '>' to data type. '<' means that encoding is little-endian (least significant is stored in smallest address). '>' means that encoding is big-endian (most significant byte is stored in smallest address).

dtype Object 使用以下语法构造-

numpy.dtype(object, align, copy)

参数是-

  • Object -要转换为数据类型 Object

  • Align -如果为true,则向该字段添加填充以使其类似于C-struct

  • 复制-制作dtype Object 的新副本。如果为false,则输出为对内置数据类型 Object 的引用

例子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'和 float字段'分数'。此dtype应用于ndarray Object 。

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

  • 'M'-日期时间

  • 'O'-(Python) Object

  • 'S','a'-(字节)字符串

  • 'U'-Unicode

  • 'V'-原始数据(无效)

在本章中,我们将讨论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还提供了一种调整形状功能以调整数组大小。

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 Object 具有以下属性。此函数返回其当前值。

Sr.No.Attribute & Description
1

C_CONTIGUOUS(C)

数据在单个C样式连续段中

2

F_CONTIGUOUS(F)

数据在单个Fortran样式的连续段中

3

OWNDATA(O)

该数组拥有它使用的内存或从另一个 Object 借用的内存

4

可写(W)

数据区可以被写入。将此设置为False会锁定数据,使其变为只读

5

ALIGNED(A)

数据和所有元素都针对硬件进行了适当对齐

6

UPDATEIFCOPY(U)

该数组是其他数组的副本。释放此数组后,基本数组将使用该数组的内容进行更新

下面的示例显示标志的当前值。

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

输出如下-

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

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

numpy.empty

它创建指定形状和dtype的未初始化数组。它使用以下构造函数-

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

构造函数采用以下参数。

Sr.No.Parameter & Description
1

形状

int或int元组中的空数组的形状

2

Dtype

所需的输出数据类型。可选的

3

订单

" C"表示C样式的行主数组," F"表示FORTRAN样式的行主数组

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

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

输出如下-

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

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

numpy.zeros

返回指定大小的新数组,并用零填充。

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

构造函数采用以下参数。

Sr.No.Parameter & Description
1

形状

int或int序列中的空数组的形状

2

Dtype

所需的输出数据类型。可选的

3

订单

" C"表示C样式的行主数组," F"表示FORTRAN样式的行主数组

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

构造函数采用以下参数。

Sr.No.Parameter & Description
1

形状

int或int元组中的空数组的形状

2

Dtype

所需的输出数据类型。可选的

3

订单

" C"表示C样式的行主数组," F"表示FORTRAN样式的行主数组

例子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.asarray

该函数与numpy.array相似,除了它具有较少的参数。该例程对于将Python序列转换为ndarray很有用。

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

构造函数采用以下参数。

Sr.No.Parameter & Description
1

a

以任何形式输入数据,例如列表,元组列表,元组,元组元组或列表元组

2

dtype

默认情况下,输入数据的数据类型应用于输出ndarray

3

顺序的

C(行专业)或F(列专业)。 C是默认值

以下示例说明了如何使用 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

此函数将缓冲区解释为一维数组。公开缓冲区接口的任何 Object 都用作返回 ndarray 的参数。

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

构造函数采用以下参数。

Sr.No.Parameter & Description
1

缓冲区

任何公开缓冲区接口的 Object

2

dtype

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

3

计数

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

4

偏移量

要读取的起始位置。默认为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

此函数从任何可迭代 Object 中构建一个 ndarray Object 。此函数返回一个新的一维数组。

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

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

Sr.No.Parameter & Description
1

可迭代

任何可迭代的 Object

2

dtype

输出数组的数据类型

3

计数

要从迭代器读取的项目数。默认值为-1,表示要读取的所有数据

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

例子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.arange

此函数返回一个 ndarray Object ,该 Object 包含给定范围内的均匀间隔的值。该函数的格式如下-

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

构造函数采用以下参数。

Sr.No.Parameter & Description
1

开始

间隔的开始。如果省略,则默认为0

2

停止

间隔的结尾(不包括此数字)

3

步骤

值之间的间隔,默认为1

4

dtype

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

以下示例显示如何使用此功能。

例子1

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

其输出如下-

[0  1  2  3  4]

例子2

import numpy as np 
# dtype 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)

构造函数采用以下参数。

Sr.No.Parameter & Description
1

开始

序列的起始值

2

停止

序列的结束值,如果端点设置为true,则包含在序列中

3

可以的

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

4

终点

默认情况下为True,因此终止值包含在序列中。如果为假,则不包含

5

重走

如果为true,则返回样本并在连续数字之间步进

6

dtype

输出 ndarray 的数据类型

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

例子1

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

它的输出将是-

[10.   12.5   15.   17.5  20.]

例子2

# endpoint 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 Object ,该 Object 包含在对数刻度上均匀间隔的数字。标度的起点和终点是基准的索引,通常为10。

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

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

Sr.No.Parameter & Description
1

开始

序列的起点是base start

2

停止

序列的最终值为base stop

3

可以的

范围之间的值数。默认值为50

4

终点

如果为true,则stop是范围内的最后一个值

5

基本

日志空间的底数,默认为10

6

dtype

输出数组的数据类型。如果未给出,则取决于其他输入参数

以下示例将帮助您理解 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.] 

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

如前所述,ndarray Object 中的项遵循从零开始的索引。可以使用三种类型的索引方法-字段访问,基本切片和高级索引。

Basic slicing is an extension of Python's basic concept of slicing to n dimensions. A Python slice object is constructed by giving start, stop, and 步骤 parameters to the built-in slice function. This slice object is passed to the array to extract a part of array.

例子1

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

其输出如下-

[2  4  6]

在上面的示例中, ndarray Object 是通过 arange()函数准备的。然后,分别使用开始值,停止值和步长值2、7和2定义切片 Object 。当将此切片 Object 传递给ndarray时,将对它的一部分进行索引(从索引2到7并以2的步长)进行切片。

通过将由冒号:(start:stop:step)分隔的切片参数直接分配给 ndarray Object ,也可以获得相同的输出。

例子2

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

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

[2  4  6]

如果仅输入一个参数,则将返回与索引相对应的单个项目。如果在其前面插入:,则将从该索引开始的所有项目都将被提取。如果使用两个参数(在它们之间带有:),则将对两个索引(不包括停止索引)之间具有默认第一步的项目进行切片。

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

可以从作为非元组序列的ndarray,整数或布尔数据类型的ndarray Object 或具有至少一项作为序列 Object 的元组中进行选择。高级索引总是返回数据的副本。与此相反,切片仅呈现视图。

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

整数索引

这种机制有助于根据N维索引选择数组中的任意项。每个整数数组代表该维度的索引数。当索引由与目标ndarray的维数一样多的整数数组组成时,它变得很简单。

在以下示例中,从ndarray Object 的每一行中选择了指定列的一个元素。因此,行索引包含所有行号,列索引指定要选择的元素。

例子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 Object 。

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

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

布尔数组索引

当输出 Object 是布尔运算(例如比较运算符)的输出时,将使用这种类型的高级索引。

例子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在算术运算期间处理不同形状的数组的能力。数组上的算术运算通常在相应的元素上完成。如果两个数组的形状完全相同,则可以平稳执行这些操作。

例子1

import numpy as np 

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

其输出如下-

[10   40   90   160]

如果两个数组的维数不同,则无法进行元素到元素的操作。但是,由于广播功能的原因,在NumPy中仍然可以对非相似形状的数组进行操作。较小的数组被广播到较大的数组,以使其具有兼容的形状。

如果满足以下规则,则可以进行广播-

  • 具有小于 ndim 的数组的形状前面带有'1'。

  • 输出形状的每个尺寸中的尺寸是该尺寸中输入尺寸的最大值。

  • 如果输入在特定维度上的大小与输出大小匹配或其值恰好为1,则可以在计算中使用输入。

  • 如果输入的维大小为1,则该维中的第一个数据条目将用于沿该维的所有计算。

如果上述规则产生有效输出并且以下条件之一为真,则表示一组数组可以可广播:

  • 数组的形状完全相同。

  • 数组具有相同的维数,每个维的长度可以是公共长度或1。

  • 尺寸过小的数组可以以长度为1的形状作为其形状的前缀,因此上述属性为true。

以下程序显示了广播示例。

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

The following figure demonstrates how array b is broadcast to become compatible with a .

array

NumPy包包含一个迭代器 Object numpy.nditer 。这是一个有效的多维迭代器 Object ,使用它可以遍历数组。使用Python的标准Iterator接口访问数组的每个元素。

让我们使用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 Object 来强制使用特定顺序。

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 Object 还有另一个可选参数,称为 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'参数,该参数可以采用以下值-

Sr.No.Parameter & Description
1

c_index

可以跟踪C_order索引

2

f_index

跟踪Fortran_order索引

3

多索引

可以跟踪一次迭代的索引类型

4

external_loop

使给定的值是具有多个值的一维数组,而不是零维数组

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

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]

广播迭代

If two arrays are broadcastable, a combined nditer object is able to iterate upon them concurrently. Assuming that an array a has dimension 3X4, and there is another array b of dimension 1X4, the iterator of following type is used (array b is broadcast to size of 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包中提供了一些例程来处理ndarray Object 中的元素。它们可以分为以下类型-

改变形状

Sr.No.Shape & Description
1 reshape

在不更改数据的情况下为数组赋予新的形状

2 flat

数组上的一维迭代器

3 flatten

返回折叠成一维的数组的副本

4 ravel

返回一个连续的扁平数组

转置操作

Sr.No.Operation & Description
1 transpose

排列数组的尺寸

2 ndarray.T

与self.transpose()相同

3 rollaxis

向后滚动指定轴

4 swapaxes

互换数组的两个轴

改变尺寸

Sr.No.Dimension & Description
1 broadcast

产生模仿广播的 Object

2 broadcast_to

将数组广播为新形状

3 expand_dims

扩展数组的形状

4 squeeze

从数组形状中删除一维条目

连接数组

Sr.No.Array & Description
1 concatenate

沿现有轴连接一系列数组

2 stack

沿新轴连接一系列数组

3 hstack

水平(水平列)按顺序堆叠数组

点我分享笔记