NumPy - 广播

广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。对数组的算术运算通常在相应的元素上进行。如果两个阵列具有完全相同的形状，则这些操作被无缝执行。

示例

import numpy as np
a = np.arange(1,6)
b = np.arange(3,8)
a*b
#结果
array([ 3,  8, 15, 24, 35])

如果两个数组的维数不相同，则元素到元素的操作是不可能的。然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。

如果满足以下规则，可以进行广播：

ndim较小的数组会在前面追加一个长度为 1 的维度。
输出数组的每个维度的大小是输入数组该维度大小的最大值。
如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。
如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。

数组拥有相同形状。
数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。

扫描二维码关注公众号，回复： 1623026 查看本文章
数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。

示例 2

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])  
a * b的结果
array([[  0.,   0.,   0.],
       [ 10.,  20.,  30.],
       [ 20.,  40.,  60.],
       [ 30.,  60.,  90.]])

下面的图片展示了数组如何通过广播来与数组b如何通过广播来与数组a兼容

NumPy广播

数组的广播功能还可以进行加，减，乘，除的运算。#注意两个数组的的机构必须列数必须相同，并且有一个为一行的数组即

(x ,y)*(1,y)

NumPy - 数组上的迭代

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

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

a = np.arange(0,60,5).reshape(3,4) 
#a的结果

array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])

for i in np.nditer(a): print(i)#输出结果0510152025303540455055
#由此看出是一行一行的迭代

示例 2

迭代的顺序匹配数组的内容布局，而不考虑特定的排序。这可以通过迭代上述数组的转置来看到。

a = np.arange(0,60,5).reshape(3,4).T 
#a的结果

array([[ 0, 20, 40],
       [ 5, 25, 45],
       [10, 30, 50],
       [15, 35, 55]])

for i in np.nditer(a): print(i)#结果0510152025303540455055
#由此看出一列一列的迭代

迭代顺序

如果相同元素使用 C，F 风格顺序存储，则迭代器选择以更有效的方式对数组进行迭代。

示例

a = np.arange(0,60,5).reshape(3,4).T.copy(order='C')  
#a 的结果

array([[ 0, 20, 40],
       [ 5, 25, 45],
       [10, 30, 50],
       [15, 35, 55]])

for i in np.nditer(a):
    print(i)
#结果
0
20
40
5
25
45
10
30
50
15
35
55


a = np.arange(0,60,5).reshape(3,4).T.copy(order='F')
for i in np.nditer(a):
    print(i)

#结果

#由此可看c风格是以一行一行的迭代，F风格一列一列的迭代

示例

可以通过显式提醒，来强制nditer对象使用某种顺序：

a = np.arange(0,60,5).reshape(3,4)
#a的结果
array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])
for x in np.nditer(a, order ='C'):
    print(x)
#c风格的结果
0
5
10
15
20
25
30
35
40
45
50
55
for x in np.nditer(a, order ='F'):
    print(x)
#F风格的结果
0
20
40
5
25
45
10
30
50
15
35
55

外部循环

nditer类的构造器拥有flags参数，它可以接受下列值：

序号	参数及描述
1.	`c_index` 可以跟踪 C 顺序的索引
2.	`f_index` 可以跟踪 Fortran 顺序的索引
3.	`multi-index` 每次迭代可以跟踪一种索引类型
4.	`external_loop` 给出的值是具有多个值的一维数组，而不是零维数组

示例

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

a = np.arange(0,60,5).reshape(3,4)
for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):  
        print(x)
[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]

广播迭代

如果两个数组是可广播的，nditer组合对象能够同时迭代它们。假设数组a具有维度 3X4，并且存在维度为 1X4 的另一个数组b，则使用以下类型的迭代器(数组b被广播到a的大小)。

示例

a = np.arange(0,60,5).reshape(3,4)
b = np.arange(1,5)
for x,y in np.nditer([a,b]):
    print('%d:%d' % (x,y))
#结果
0:1
5:2
10:3
15:4
20:1
25:2
30:3
35:4
40:1
45:2
50:3
55:4

#注意要保证数组的列数必须相同比如（x,y)(1,y) 或者（x,y)(x,y)

NumPy - 数组操作

NumPy包中有几个例程用于处理ndarray对象中的元素。它们可以分为以下类型：

修改形状

序号	形状及描述
1.	`reshape` 不改变数据的条件下修改形状
2.	`flat` 数组上的一维迭代器
3.	`flatten` 返回折叠为一维的数组副本
4.	`ravel` 返回连续的展开数组

`numpy.reshape`

这个函数在不改变数据的条件下修改形状，它接受如下参数：

numpy.reshape(arr, newshape, order')

其中：

arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：'C'为 C 风格顺序，'F'为 F 风格顺序，'A'为保留原顺序。

例子

a = np.arange(9).reshape(3,3)
结果
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
#变成了3x3的二维数组

`numpy.ndarray.flat 该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器。`

a = np.arange(9).reshape(3,3)
a.flat[7]
#结果
7

`numpy.ndarray.flatten`

该函数返回折叠为一维的数组副本，函数接受下列参数：

ndarray.flatten(order)

其中：

order：'C' — 按行，'F' — 按列，'A' — 原顺序，'k' — 元素在内存中的出现顺序。

例子

a = np.arange(9).reshape(3,3)
a.flatten()
#结果为
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
# F 展开
a.flatten(order='F')
#结果
array([0, 3, 6, 1, 4, 7, 2, 5, 8])
#C展开
a.flatten(order='C')
#结果
a
array([0, 1, 2, 3, 4, 5, 6, 7, 8])

`numpy.ravel`

这个函数返回展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数。

numpy.ravel(a, order)

构造器接受下列参数：

order：'C' — 按行，'F' — 按列，'A' — 原顺序，'k' — 元素在内存中的出现顺序。

例子

a = np.arange(9).reshape(3,3)
a.ravel()
#结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
#F风格
a.ravel(order = 'F')
#结果
array([0, 3, 6, 1, 4, 7, 2, 5, 8])

翻转操作

序号	操作及描述
1.	`transpose` 翻转数组的维度
2.	`ndarray.T` 和`self.transpose()`相同
3.	`rollaxis` 向后滚动指定的轴
4.	`swapaxes` 互换数组的两个轴

`numpy.transpose`

这个函数翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数：

numpy.transpose(arr, axes)

其中：

arr：要转置的数组
axes：整数的列表，对应维度，通常所有维度都会翻转。

例子

a = np.arange(12).reshape(3,4)
np.transpose(a)
#结果
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])
a的结果
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

#或者用

`numpy.ndarray.T 和 numpy.transpose 返回的结果一样`

a = np.arange(12).reshape(3,4)
a.T
#结果
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])
a的结果
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

`numpy.rollaxis`

该函数向后滚动特定的轴，直到一个特定位置。这个函数接受三个参数：

numpy.rollaxis(arr, axis, start)

其中：

arr：输入数组
axis：要向后滚动的轴，其它轴的相对位置不会改变
start：默认为零，表示完整的滚动。会滚动到特定位置。

例子

a = np.arange(8).reshape(2,2,2)

# 将轴 2 滚动到轴 0(宽度到深度)np.rollaxis(a,2) 
#结果
array([[[0, 2],
        [4, 6]],

       [[1, 3],
        [5, 7]]])

现在交换轴 0(深度方向)到轴 2(宽度方向）np.rollaxis(a,2,1)

array([[[0, 2],
        [1, 3]],

       [[4, 6],
        [5, 7]]])

修改维度

序号	维度和描述
1.	`broadcast` 产生模仿广播的对象
2.	`broadcast_to` 将数组广播到新形状
3.	`expand_dims` 扩展数组的形状
4.	`squeeze` 从数组的形状中删除单维条目

`broadcast`

如前所述，NumPy 已经内置了对广播的支持。此功能模仿广播机制。它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。

该函数使用两个数组作为输入参数。下面的例子说明了它的用法。

x = np.arange(9).reshape(3,3)
y = np.array([4, 5, 6]) 
b = np.broadcast(x,y)
c = np.empty(b.shape)
#输出c的结果 x + y
array([[  4.,   6.,   8.],
       [  7.,   9.,  11.],
       [ 10.,  12.,  14.]])
#方法二
c.flat = [u + v for (u,v) in b]
#x + y
array([[  4.,   6.,   8.],
       [  7.,   9.,  11.],
       [ 10.,  12.,  14.]])

`numpy.broadcast_to`

此函数将数组广播到新形状。它在原始数组上返回只读视图。它通常不连续。如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。

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

该函数接受以下参数。

numpy.broadcast_to(array, shape, subok)

例子

a = np.arange(16).reshape(2,2,4)
a.shape
np.broadcast_to(a,(4,2,2,4))
array([[[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7]],

        [[ 8,  9, 10, 11],
         [12, 13, 14, 15]]],


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

        [[ 8,  9, 10, 11],
         [12, 13, 14, 15]]],


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

        [[ 8,  9, 10, 11],
         [12, 13, 14, 15]]],


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

        [[ 8,  9, 10, 11],
         [12, 13, 14, 15]]]])

`numpy.expand_dims`

函数通过在指定位置插入新的轴来扩展数组形状。该函数需要两个参数：

numpy.expand_dims(arr, axis)

其中：

arr：输入数组
axis：新轴插入的位置

x = np.arange(18).reshape(2,3,3)
x.shape
(2,3,3)
#这里 axis <=x.ndim
 y = np.expand_dims(x, axis = 1)
y.shape
#结果
(2, 1, 3, 3)
#
y = np.expand_dims(x, axis = 0)
y.shape
(1, 2, 3, 3)

#由此看出把一个三维的数组改变成为4维的数组

axis = 0时，y.shape[0] = 1

然后根据axis 的参数跟y.shape[axis]进行互换

`numpy.squeeze`

函数从给定数组的形状中删除一维条目。此函数需要两个参数。

numpy.squeeze(arr, axis)

其中：

arr：输入数组
axis：整数或整数元组，用于选择形状中单一维度条目的子集

例子

x = np.arange(18).reshape(1,2,3,3)
x.shape
(1,2,3,3)
y = np.squeeze(x)
y.shape
#结果
(2, 3, 3)

#在这里x.shape[0]必须为 1，否则会跟原来的结构一样

`numpy.concatenate`

数组的连接是指连接。此函数用于沿指定轴连接相同形状的两个或多个数组。该函数接受以下参数。

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

其中：

a1, a2, ...：相同类型的数组序列
axis：沿着它连接数组的轴，默认为 0

a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
#沿轴 0 连接两个数组
np.concatenate((a,b))
#结果
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])
##沿轴 1 连接两个数组：
np.concatenate((a,b),axis=1)
#结果
array([[1, 2, 5, 6],
       [3, 4, 7, 8]])

`numpy.stack`

此函数沿新轴连接数组序列。此功能添加自 NumPy 版本 1.10.0。需要提供以下参数。

numpy.stack(arrays, axis)

其中：

arrays：相同形状的数组序列
axis：返回数组中的轴，输入数组沿着它来堆叠

a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])

#'沿轴 1 堆叠两个数组：'
np.stack((a,b),1)
array([[[1, 2],
        [5, 6]],

       [[3, 4],
        [7, 8]]])

#'沿轴 0 堆叠两个数组：'
np.stack((a,b),0)
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])

`numpy.hstack`

numpy.stack函数的变体，通过堆叠来生成水平的单个数组。

例子

a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
#水平堆叠
np.hstack((a,b))
#结果
array([[1, 2, 5, 6],
       [3, 4, 7, 8]])

`numpy.vstack`

numpy.stack函数的变体，通过堆叠来生成竖直的单个数组。

a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
#垂直堆叠 
np.vstack((a,b))
#结果
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

数组分割

序号	数组及操作
1.	`split` 将一个数组分割为多个子数组
2.	`hsplit` 将一个数组水平分割为多个子数组(按列)
3.	`vsplit` 将一个数组竖直分割为多个子数组(按行)

`numpy.split`

该函数沿特定的轴将数组分割为子数组。函数接受三个参数：

numpy.split(ary, indices_or_sections, axis)

其中：

ary：被分割的输入数组
indices_or_sections：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。如果此参数是一维数组，则其元素表明要创建新子数组的点。
axis：默认为 0

例子

a = np.arange(9)
#将数组分为三个大小相等的子数组
np.split(a,3)
#结果
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
#将数组在一维数组中表明的位置分割
np.split(a,[2,4,7])
#结果
[array([0, 1]), array([2, 3]), array([4, 5, 6]), array([7, 8])]

`numpy.hsplit`

numpy.hsplit是split()函数的特例，其中轴为 1 表示水平分割，无论输入数组的维度是什么

a = np.arange(16).reshape(4,4)
#水平分割
np.hsplit(a,2)
#结果
[array([[ 0,  1],
        [ 4,  5],
        [ 8,  9],
        [12, 13]]), array([[ 2,  3],
        [ 6,  7],
        [10, 11],
        [14, 15]])]

`numpy.vsplit`

numpy.vsplit是split()函数的特例，其中轴为 0 表示竖直分割，无论输入数组的维度是什么。下面的例子使之更清楚。

a = np.arange(16).reshape(4,4)
#竖直分割
np.vsplit(a,2)#结果[array([[0, 1, 2, 3], [4, 5, 6, 7]]), array([[ 8, 9, 10, 11], [12, 13, 14, 15]])]

添加/删除元素

序号	元素及描述
1.	`resize` 返回指定形状的新数组
2.	`append` 将值添加到数组末尾
3.	`insert` 沿指定轴将值插入到指定下标之前
4.	`delete` 返回删掉某个轴的子数组的新数组
5.	`unique` 寻找数组内的唯一元素

`numpy.resize`

此函数返回指定大小的新数组。如果新大小大于原始大小，则包含原始数组中的元素的重复副本。该函数接受以下参数。

numpy.resize(arr, shape)

其中：

arr：要修改大小的输入数组
shape：返回数组的新形状

例子

a = np.arange(16).reshape(4,4)

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

np.resize(a, (4,2,3))#结果array([[[ 0, 1, 2], [ 3, 4, 5]], [[ 6, 7, 8], [ 9, 10, 11]], [[12, 13, 14], [15, 0, 1]], [[ 2, 3, 4], [ 5, 6, 7]]])

要注意 a 的元素在 b 中重复出现，因为尺寸变大了

`numpy.append`

此函数在输入数组的末尾添加值。附加操作不是原地的，而是分配新的数组。此外，输入数组的维度必须匹配否则将生成ValueError。

函数接受下列函数：

numpy.append(arr, values, axis)

其中：

arr：输入数组
values：要向arr添加的值，比如和arr形状相同(除了要添加的轴)
axis：沿着它完成操作的轴。如果没有提供，两个参数都会被展开。

例子

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

np.append(a,b)
#结果
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,  0,
        1,  2,  3,  4,  5,  6,  7])
#axis=0时
np.append(a,b,axis=0)
#结果
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [ 0,  1,  2,  3],
       [ 4,  5,  6,  7]])
#axis=1
np.append(a,b,axis=1)
#会报错
ValueError：除了级联轴之外，所有输入数组的维数必须精确匹配
a,b的结构必须相同
我修改b的结构
b = np.arange(16).reshape(4,4)

np.append(a,b,axis=0)
#结果
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

`numpy.insert`

此函数在给定索引之前，沿给定轴在输入数组中插入值。如果值的类型转换为要插入，则它与输入数组不同。插入没有原地的，函数会返回一个新数组。此外，如果未提供轴，则输入数组会被展开。

insert()函数接受以下参数：

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

其中：

arr：输入数组
obj：在其之前插入值的索引
values：要插入的值
axis：沿着它插入的轴，如果未提供，则输入数组会被展开

例子

a = np.arange(16).reshape(4,4)
#未传递 Axis 参数。 在插入之前输入数组会被展开
np.insert(a,3,[-11,-12])
#结果
array([  0,   1,   2, -11, -12,   3,   4,   5,   6,   7,   8,   9,  10,
        11,  12,  13,  14,  15])
#传递了 Axis 参数。 会广播值数组来配输入数组沿轴 0 广播
np.insert(a,2,[11],axis = 0)

#结果
array([[ 0,  1,  2,  3],
      [ 4,  5,  6,  7],
     [11, 11, 11, 11],
    [ 8,  9, 10, 11],
 [12, 13, 14, 15]])
#传递了 Axis 参数。 会广播值数组来配输入数组沿轴 1 广播
np.insert(a,2,[11],axis = 1)
#结果
array([[ 0,  1, 11,  2,  3],

[ 4,  5, 11,  6,  7],
[ 8,  9, 11, 10, 11],
[12, 13, 11, 14, 15]]）

`numpy.delete`

此函数返回从输入数组中删除指定子数组的新数组。与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开。该函数接受以下参数：

Numpy.delete(arr, obj, axis)

其中：

arr：输入数组
obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

例子

a = np.arange(12).reshape(3,4)
np.delete(a,5)
#结果
array([ 0,  1,  2,  3,  4,  6,  7,  8,  9, 10, 11])
#传递 Axis 参数。

沿轴 1
a = np.arange(12).reshape(3,4)
np.delete(a,2,axis=1)
#结果
array([[ 0,  1,  3],
       [ 4,  5,  7],
       [ 8,  9, 11]]）

 
          #传递 Axis 参数。沿轴0
a = np.arange(12).reshape(3,4）
np.delete(a,2,axis=0)
#结果

array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

 
           # 包含从数组中删除的替代值的切片 
           a = np.arange(18).reshape(2,3,3) 
           np.delete(a, np.s_[3:9:2]) 
          

array([ 0,  1,  2,  4,  6,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17])

`numpy.unique`

此函数返回输入数组中的去重元素数组。该函数能够返回一个元组，包含去重数组和相关索引的数组。索引的性质取决于函数调用中返回参数的类型。

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

其中：

arr：输入数组，如果不是一维数组则会展开
return_index：如果为true，返回输入数组中的元素下标
return_inverse：如果为true，返回去重数组的下标，它可以用于重构输入数组
return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

例子

# 第一个数组的去重值
a = np.array([5,2,6,2,7,5,6,8,2,9])
np.unique(a)
#结果
array([2, 5, 6, 7, 8, 9])
# 去重数组的索引数组

indices = np.unique(a, return_index = True)
indices 
#结果
(array([2, 5, 6, 7, 8, 9]), array([1, 0, 2, 4, 7, 9]))
# 返回去重元素的重复数量：

indices = np.unique(a,return_counts = True)
#结果
(array([2, 5, 6, 7, 8, 9]), array([3, 2, 2, 1, 1, 1]))

#二维
a = np.array([[1,2,3],[34,2,1],[3,98,0]])
np.unique(a)
#结果
array([ 0,  1,  2,  3, 34, 98])
# 去重数组的索引数组
indices = np.unique(a, return_index = True)
#结果
(array([ 0,  1,  2,  3, 34, 98]), array([8, 0, 1, 2, 3, 7]))
# 返回去重元素的重复数量：

indices = np.unique(a,return_counts = True)
#结果
(array([ 0,  1,  2,  3, 34, 98]), array([1, 2, 2, 2, 1, 1]))

NumPy - 算数函数

很容易理解的是，NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数，算术运算的函数，复数处理函数等。

三角函数

NumPy 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值。

示例

a = np.array([0,30,45,60,90]) 
# 通过乘 pi/180 转化为弧度
#数组中角度的正弦值
np.sin(a*np.pi/180)
#结果
array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])
# 数组中角度的余弦值
np.cos(a*np.pi/180)
#结果
array([  1.00000000e+00,   8.66025404e-01,   7.07106781e-01,
         5.00000000e-01,   6.12323400e-17])
# 数组中角度的正切值

np.tan(a*np.pi/180)
#结果
array([  0.00000000e+00,   5.77350269e-01,   1.00000000e+00,
         1.73205081e+00,   1.63312394e+16])

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

示例

a = np.array([0,30,45,60,90]) 
# 含有正弦值的数组：
sin = np.sin(a*np.pi/180)  
# 计算角度的反正弦，返回值以弧度为单位：
inv = np.arcsin(sin)  
#结果
array([ 0.        ,  0.52359878,  0.78539816,  1.04719755,  1.57079633])
#'通过转化为角度制来检查结果：'  
np.degrees(inv)
#结果
array([  0.,  30.,  45.,  60.,  90.])
#余玄
cos = np.cos(a*np.pi/180)
#反余玄
inv = np.arccos(cos)
#结果
array([ 0.        ,  0.52359878,  0.78539816,  1.04719755,  1.57079633])
#通过转化为角度制来检查结果
np.degrees(inv)
#结果
array([  0.,  30.,  45.,  60.,  90.])
#正切
tan = np.tan(a*np.pi/180)
#反正切
inv = np.arctan(tan)
#结果
array([ 0.        ,  0.52359878,  0.78539816,  1.04719755,  1.57079633])
#通过转化为角度制来检查结果
np.degrees(inv)
#结果
array([  0.,  30.,  45.,  60.,  90.])

舍入函数

`numpy.around()`

这个函数返回四舍五入到所需精度的值。该函数接受以下参数。

numpy.around(a,decimals)

其中：

序号	参数及描述
1.	`a` 输入数组
2.	`decimals` 要舍入的小数位数。默认值为0。如果为负，整数将四舍五入到小数点左侧的位置

示例

a = np.array([1.0,5.55,  123,  0.567,  25.532])
np.around(a)
#结果
array([   1.,    6.,  123.,    1.,   26.])
np.around(a, decimals = 1) 
#结果
array([   1. ,    5.6,  123. ,    0.6,   25.5])

`numpy.floor()`

此函数返回不大于输入参数的最大整数。即标量x 的下限是最大的整数i ，使得i <= x。注意在Python中，向下取整总是从 0 舍入。

示例

a = np.array([-1.7,  1.5,  -0.2,  0.6,  10]) 
np.floor(a)
#结果
array([ -2.,   1.,  -1.,   0.,  10.])

`numpy.ceil()`

ceil()函数返回输入值的上限，即，标量x的上限是最小的整数i ，使得i> = x。

示例

a = np.array([-1.7,  1.5,  -0.2,  0.6,  10]) 
np.ceil(a)
#结果
array([ -1.,   2.,  -0.,   1.,  10.])

NumPy - 算数运算

用于执行算术运算(如add()，subtract()，multiply()和divide())的输入数组必须具有相同的形状或符合数组广播规则。

式列

a = np.arange(9, dtype = np.float_).reshape(3,3)  
b = np.array([10,10,10])  
# 两个数组相加：'  
np.add(a,b)  
#结果
array([[ 10.,  11.,  12.],
       [ 13.,  14.,  15.],
       [ 16.,  17.,  18.]])
#两个数组相减：'  
np.subtract(a,b)  
#结果
array([[-10.,  -9.,  -8.],
       [ -7.,  -6.,  -5.],
       [ -4.,  -3.,  -2.]])
#  '两个数组相乘：'  
np.multiply(a,b)  
#结果
array([[  0.,  10.,  20.],
       [ 30.,  40.,  50.],
       [ 60.,  70.,  80.]])
# 两个数组相除：'
np.divide(a,b)
#结果
array([[ 0. ,  0.1,  0.2],
       [ 0.3,  0.4,  0.5],
       [ 0.6,  0.7,  0.8]])

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

numpy.reciprocal()

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

示例

a = np.array([0.25,  1.33,  1,  0,  100])  
np.reciprocal(a) 
#结果
array([ 4.       ,  0.7518797,  1.       ,        inf,  0.01     ])

`numpy.power()`

此函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

a = np.arange(9).reshape(3,3)
np.power(a,4)
#结果
array([[   0,    1,   16],
       [  81,  256,  625],
       [1296, 2401, 4096]])
b = np.array([1,2,3])
np.power(a,b)
#结果
array([[  0,   1,   8],
       [  3,  16, 125],
       [  6,  49, 512]])

`numpy.mod()`

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

a = np.array([10,20,30]) 
b = np.array([3,5,7])
np.mod(a,b)
#结果
array([1, 0, 2])
np.remainder(a,b)
#结果
array([1, 0, 2])

以下函数用于对含有复数的数组执行操作。

numpy.real() 返回复数类型参数的实部。
numpy.imag() 返回复数类型参数的虚部。
numpy.conj() 返回通过改变虚部的符号而获得的共轭复数。
numpy.angle() 返回复数参数的角度。函数的参数是degree。如果为true，返回的角度以角度制来表示，否则为以弧度制来表示。

a = np.array([-5.6j,  0.2j,  11.  ,  1+1j])  
# 调用 real() 函数：'  
np.real(a)  
 # 调用 imag() 函数：'  
np.imag(a) 
#结果
array([-5.6,  0.2,  0. ,  1. ])
# 调用 conj() 函数：'  
np.conj(a) 
#结果
array([ -0.+5.6j,   0.-0.2j,  11.-0.j ,   1.-1.j ])
#'调用 angle() 函数：'  
np.angle(a)  
#结果
array([-1.57079633,  1.57079633,  0.        ,  0.78539816])
#再次调用 angle() 函数(以角度制返回)  
np.angle(a,deg = True) 
#结果
array([-90.,  90.,   0.,  45.])

NumPy - 统计函数

NumPy 有很多有用的统计函数，用于从数组中给定的元素中查找最小，最大，百分标准差和方差等。函数说明如下：

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

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

示例

a = np.array([[3,7,5],[8,4,3],[2,4,9]]) 
np.amin(a,1) 
#结果行中的最小值
array([3, 3, 2])
np.amin(a,0)
#结果列中的最小值
array([2, 4, 3])
np.amax(a,1) 
#结果,行中最大值
array([7, 8, 9])
np.amax(a,0)
#结果列中最大值
array([8, 7, 9])

numpy.percentile()

百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比。函数numpy.percentile()接受以下参数。

numpy.percentile(a, q, axis)

其中：

序号	参数及描述
1.	`a` 输入数组
2.	`q` 要计算的百分位数，在 0 ~ 100 之间
3.	`axis` 沿着它计算百分位数的轴

示例

a = np.array([[30,40,70],[80,20,10],[50,90,60]])
np.percentile(a,50,0)  
#以列
array([ 80.,  90.,  70.])
np.percentile(a,50,1)  
#以行
array([ 40.,  20.,  60.])

`numpy.mean()`

算术平均值是沿轴的元素的总和除以元素的数量。 numpy.mean()函数返回数组中元素的算术平均值。如果提供了轴，则沿其计算。

示例

a = np.array([[1,2,3],[3,4,5],[4,5,6]]) 
np.mean(a)
#结果
3.6666666666666665
np.mean(a,0)
#列计算
array([ 2.66666667,  3.66666667,  4.66666667])
np.mean(a,1)
#行计算
array([ 2.,  4.,  5.])

`numpy.average()`

加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。 numpy.average()函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。该函数可以接受一个轴参数。如果没有指定轴，则数组会被展开。

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

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

示例

a = np.array([1,2,3,4]) 
#不指定权重时相当于 mean 函数
np.average(a) 
#结果
2.5
wts = np.array([4,3,2,1])  
np.average(a,weights = wts) 
#结果
2.0
#权重的和：
np.average([1,2,3,4],weights =  [4,3,2,1], returned =  True)
#结果
(2.0, 10.0)

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

a = np.arange(6).reshape(3,2)  
wt = np.array([3,5])  
np.average(a, axis =  1, weights = wt) 
#结果
array([ 0.625,  2.625,  4.625])
np.average(a, axis =  1, weights = wt, returned =  True)
#结果
(array([ 0.625,  2.625,  4.625]), array([ 8.,  8.,  8.]))
#

标准差

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

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

如果数组是[1，2，3，4]，则其平均值为2.5。因此，差的平方是[2.25,0.25,0.25,2.25]，并且其平均值的平方根除以4，即sqrt(5/4)是1.1180339887498949。

示例

print np.std([1,2,3,4])
输出如下
1.1180339887498949

方差

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

示例

np.var([1,2,3,4])
#结果
1.25

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

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

种类	速度	最坏情况	工作空间	稳定性
`'quicksort'`(快速排序)	1	`O(n^2)`	0	否
`'mergesort'`(归并排序)	2	`O(n*log(n))`	~n/2	是
`'heapsort'`(堆排序)	3	`O(n*log(n))`	0	否

`numpy.sort()`

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

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

其中：

序号	参数及描述
1.	`a` 要排序的数组
2.	`axis` 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序
3.	`kind` 默认为`'quicksort'`(快速排序)
4.	`order` 如果数组包含字段，则是要排序的字段

示例

a = np.array([[3,7],[9,1]])
np.sort(a) 
#结果
array([[3, 7],
       [1, 9]])
#'沿轴 0 排序：'  
np.sort(a, axis =  0)  
#结果
array([[3, 1],
       [9, 7]])
# 在 sort 函数中排序字段 
dt = np.dtype([('name',  'S10'),('age',  int)]) 
a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt) 
np.sort(a,order =  'name')
#结果
array([(b'amar', 27), (b'anil', 25), (b'raju', 21), (b'ravi', 17)],
      dtype=[('name', 'S10'), ('age', '<i8')])

`numpy.argsort()`

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

 
          a = np.arange(1,10).reshape(3,3)
y = np.argsort(a)
#结果
array([[0, 1, 2],
       [0, 1, 2],
       [0, 1, 2]])
 
         

`numpy.lexsort()`

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

示例

nm =  ('raju','anil','ravi','amar') 
dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
ind = np.lexsort((dv,nm)) 
#结果
array([3, 1, 0, 2])
##'使用这个索引来获取排序后的数据：'  
print([nm[i]  +  ", "  + dv[i]  for i in ind])
#结果
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

NumPy 模块有一些用于在数组内搜索的函数。提供了用于找到最大值，最小值以及满足给定条件的元素的函数。

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

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

示例

a = np.array([[30,40,70],[80,20,10],[50,90,60]]) 
np.argmax(a)
#结果
7
# 展开数组：
a.flatten() 
#结果
array([30, 40, 70, 80, 20, 10, 50, 90, 60])
#获取最大值
a.flatten()[np.argmax(a)] 
90
'沿轴 0 的最大值索引：' 
np.argmax(a, axis =  0)  
#结果
array([1, 2, 0])
# 沿轴 1 的最大值索引：' 
np.argmax(a, axis =  1)  
#结果
array([2, 0, 1])
#最小值也一样就不举列了

`numpy.nonzero()`

numpy.nonzero()函数返回输入数组中非零元素的索引。

示例

a = np.array([[30,40,0],[0,20,10],[50,0,60]])
np.nonzero (a)
#结果
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

`numpy.where()`

where()函数返回输入数组中满足给定条件的元素的索引。

示例

x = np.arange(9.).reshape(3,  3)  
x >4
#结果
array([[False, False, False],
       [False, False,  True],
       [ True,  True,  True]], dtype=bool)
x[x >4]
#结果
array([ 5.,  6.,  7.,  8.])

`numpy.extract()`

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

x = np.arange(9.).reshape(3,  3) 
# 定义条件 
condition = np.mod(x,2)  ==  0  
#结果
array([[ True, False,  True],
       [False,  True, False],
       [ True, False,  True]], dtype=bool)
np.extract(condition, x)
#结果
array([ 0.,  2.,  4.,  6.,  8.])

如有错误欢迎指正！

Nnumpy 教程（下）

NumPy - 广播

示例

示例 2

NumPy - 数组上的迭代

示例 2

迭代顺序

示例

示例

外部循环

示例

广播迭代

示例

NumPy - 数组操作

修改形状

numpy.reshape

numpy.ndarray.flat 该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器。

numpy.ndarray.flatten

numpy.ravel

翻转操作

numpy.transpose

numpy.ndarray.T 和 numpy.transpose 返回的结果一样

numpy.rollaxis

修改维度

broadcast

numpy.broadcast_to

numpy.expand_dims

numpy.squeeze

numpy.concatenate

numpy.stack

numpy.hstack

numpy.vstack

数组分割

numpy.split

numpy.hsplit

numpy.vsplit

添加/删除元素

numpy.resize

numpy.append

numpy.insert

numpy.delete

numpy.unique

NumPy - 算数函数

三角函数

舍入函数

numpy.around()

numpy.floor()

numpy.ceil()

NumPy - 算数运算

示例

numpy.power()

numpy.mod()

NumPy - 统计函数

numpy.amin() 和 numpy.amax()

示例

示例

numpy.mean()

示例

numpy.average()

示例

标准差

方差

示例

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

numpy.sort()

示例

numpy.argsort()

numpy.lexsort()

示例

numpy.argmax() 和 numpy.argmin()

示例

numpy.nonzero()

示例

numpy.where()

示例

numpy.extract()

猜你喜欢

`numpy.reshape`

`numpy.ndarray.flat 该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器。`

`numpy.ndarray.flatten`

`numpy.ravel`

`numpy.transpose`

`numpy.ndarray.T 和 numpy.transpose 返回的结果一样`

`numpy.rollaxis`

`broadcast`

`numpy.broadcast_to`

`numpy.expand_dims`

`numpy.squeeze`

`numpy.concatenate`

`numpy.stack`

`numpy.hstack`

`numpy.vstack`

`numpy.split`

`numpy.hsplit`

`numpy.vsplit`

`numpy.resize`

`numpy.append`

`numpy.insert`

`numpy.delete`

`numpy.unique`

`numpy.around()`

`numpy.floor()`

`numpy.ceil()`

`numpy.power()`

`numpy.mod()`

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

`numpy.mean()`

`numpy.average()`

`numpy.sort()`

`numpy.argsort()`

`numpy.lexsort()`

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

`numpy.nonzero()`

`numpy.where()`

`numpy.extract()`