一、什么是numpy?

　　NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

　　终极目的：读取文件数字数据进行处理

　　NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

　　　　1.一个强大的N维数组对象 ndarray

　　　　2.广播功能函数

　　　　3.整合 C/C++/Fortran 代码的工具

　　　　4.线性代数、傅里叶变换、随机数生成等功能

二、安装numpy(Windows版)

1. 首先，第一步打开电脑的运行，快捷键是win+r，然后输入cmd打开命令窗口。

   

2. 第二步，在打开的命令窗口中输入pip --version，查看电脑是否有安装pip（如果有输出版本号即已经安装好，若出现pip不是内部或外部命令则说明没有安装好），注意\'--\'前面有空格。

    

3. 第三步，如果发现自己没有安装pip，就在命令窗口中输入\'easy_install.exe pip\'这条命令进行下载。

    

4. 第四步，如果发现自己已经安装pip，但是版本是旧版本的话，可以输入pip install pip --upgrade这条命令，以此来升级pip。

   

5. 第五步，这时候可以重新输入pip --version这条命令，来查看自己的版本。

   

　　  6.第六步，有了最新版的pip之后，就可以在命令窗口输入pip install numpy，此时numpy就安装成功了。

三、NumPy Ndarray 对象

　　NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

　　ndarray 对象是用于存放同类型元素的多维数组。

　　ndarray 中的每个元素在内存中都有相同存储大小的区域。

　　ndarray 内部由以下内容组成：

　　　　一个指向数据（内存或内存映射文件中的一块数据）的指针。

　　　　数据类型或 dtype，描述在数组中的固定大小值的格子。　　　　　　

　　　　一个表示数组形状（shape）的元组，表示各维度大小的元组。

　　　　一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要\"跨过\"的字节数。

　　ndarray 的内部结构:

　　跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。

　　创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

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

参数说明：

案例：

 1 import numpy as np    #给函数取别名方便调用
 2 a = np.array([1,2,3])  
 3 print (a)
 4 #输出结果如下：[1 2 3]
 5 
 6 #实例 2
 7 # 多于一个维度  
 8 a = np.array([[1,  2],  [3,  4]])  
 9 print (a)
10 #输出结果如下：
11 # [[1  2] 
12 #  [3  4]]
13 
14 #实例 3
15 # 最小维度  
16 a = np.array([1, 2, 3, 4, 5], ndmin =  2)  
17 print (a)
18 #输出如下：[[1 2 3 4 5]]
19 
20 #实例 4
21 # dtype 参数  
22 a = np.array([1,  2,  3], dtype = complex)  
23 print (a)
24 #输出结果如下：[1.+0.j 2.+0.j 3.+0.j]

四、NumPy 数据类型

　　numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。下表列举了常用 NumPy 基本类型。

numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。

　数据类型对象 (dtype)

　　数据类型对象（numpy.dtype 类的实例）用来描述与数组对应的内存区域是如何使用，它描述了数据的以下几个方面：：

• 数据的类型（整数，浮点数或者 Python 对象）
• 数据的大小（例如， 整数使用多少个字节存储）
• 数据的字节顺序（小端法或大端法）
• 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
• 如果数据类型是子数组，那么它的形状和数据类型是什么。

　　字节顺序是通过对数据类型预先设定 < 或 > 来决定的。 < 意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。> 意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。

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

numpy.dtype(object, align, copy)

• object - 要转换为的数据类型对象
• align - 如果为 true，填充字段使其类似 C 的结构体。
• copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

 1 import numpy as np
 2 # 使用标量类型
 3 dt = np.dtype(np.int32)
 4 print(dt)
 5 # 输出结果为：int32
 6 
 7 #实例 2
 8 # int8, int16, int32, int64 四种数据类型可以使用字符串 \'i1\', \'i2\',\'i4\',\'i8\' 代替
 9 dt = np.dtype(\'i4\')
10 print(dt)  
11 #输出结果为：int32
12 #实例 3
13 
14 
15 # 字节顺序标注
16 dt = np.dtype(\'<i4\')
17 print(dt)
18 #输出结果为：int32
19 
20 #下面实例展示结构化数据类型的使用，类型字段和对应的实际类型将被创建。
21 
22 #实例 4
23 # 首先创建结构化数据类型
24 dt = np.dtype([(\'age\',np.int8)]) 
25 print(dt)
26 #输出结果为：[(\'age\', \'i1\')]
27 
28 #实例 5
29 # 将数据类型应用于 ndarray 对象
30 dt = np.dtype([(\'age\',np.int8)]) 
31 a = np.array([(10,),(20,),(30,)], dtype = dt) 
32 print(a)
33 #输出结果为：[(10,) (20,) (30,)]
34 
35 #实例 6
36 # 类型字段名可以用于存取实际的 age 列
37 import numpy as np
38 dt = np.dtype([(\'age\',np.int8)]) 
39 a = np.array([(10,),(20,),(30,)], dtype = dt) 
40 print(a[\'age\'])
41 #输出结果为：[10 20 30]

下面的示例定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks，并将这个 dtype 应用到 ndarray 对象。

import numpy as np
#实例 7
student = np.dtype([(\'name\',\'S20\'), (\'age\', \'i1\'), (\'marks\', \'f4\')]) 
print(student)
#输出结果为：[(\'name\', \'S20\'), (\'age\', \'i1\'), (\'marks\', \'f4\')]

#实例 8
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)]

五、NumPy 数组属性

　　NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。

　　在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

　　很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

NumPy 的数组中比较重要 ndarray 对象属性有：

ndarray.ndim

ndarray.ndim 用于返回数组的维数，等于秩。

import numpy as np 
 
a = np.arange(24)  
print (a.ndim)             # a 现只有一个维度
# 现在调整其大小
b = a.reshape(2,4,3)  # b 现在拥有三个维度
print (b.ndim)
#输出结果为：
#1
#3

ndarray.shape

ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示\"行数\"和\"列数\"。

ndarray.shape 也可以用于调整数组大小。

 1 import numpy as np  
 2  
 3 a = np.array([[1,2,3],[4,5,6]])  
 4 print (a.shape)
 5 #输出结果为：
 6 #(2, 3)
 7 #调整数组大小。
 8 
 9 #实例
10  
11 a = np.array([[1,2,3],[4,5,6]]) 
12 a.shape =  (3,2)  
13 print (a)
14 #输出结果为：
15 
16 #[[1 2]
17 # [3 4]
18 # [5 6]]

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

六、NumPy 创建数组

　　darray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。

　　numpy.empty

　　numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

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

　　参数说明：

　　下面是一个创建空数组的实例：

实例

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

输出结果为：

[[ 6917529027641081856  5764616291768666155]
 [ 6917529027641081859 -5764598754299804209]
 [          4497473538      844429428932120]]

注意 − 数组元素为随机值，因为它们未初始化。

numpy.zeros

创建指定大小的数组，数组元素以 0 来填充：

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

参数说明：

实例

import numpy as np
# 默认为浮点数
x = np.zeros(5)
print(x)
# 设置类型为整数
y = np.zeros((5,), dtype = np.int)
print(y)
# 自定义类型
z = np.zeros((2,2), dtype = [(\'x\', \'i4\'), (\'y\', \'i4\')])
print(z)

输出结果为：

[0. 0. 0. 0. 0.]
[0 0 0 0 0]
[[(0, 0) (0, 0)]
 [(0, 0) (0, 0)]]

numpy.ones

创建指定形状的数组，数组元素以 1 来填充：

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

参数说明：

实例

import numpy as np
# 默认为浮点数
x = np.ones(5)
print(x)
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)

输出结果为：

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

　　NumPy 从已有的数组创建数组

numpy.asarray

numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。

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

参数说明：

实例

将列表转换为 ndarray:

实例

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

输出结果为：

[1  2  3]

将元组转换为 ndarray:

实例

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

输出结果为：

[1  2  3]

将元组列表转换为 ndarray:

实例

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

输出结果为：

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

设置了 dtype 参数：

实例

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

输出结果为：

[ 1.  2.  3.]

　　NumPy 从数值范围创建数组

numpy.arange

numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：

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

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数说明：

实例

生成 0 到 5 的数组:

实例

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

输出结果如下：

[0  1  2  3  4]

设置返回类型位 float:

实例

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

输出结果如下：

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

设置了起始值、终止值及步长：

实例

import numpy as np
x = np.arange(10,20,2)
print (x)

输出结果如下：

[10  12  14  16  18]

numpy.linspace

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明：

以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。

实例

import numpy as np
a = np.linspace(1,10,10)
print(a)

输出结果为：

[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

numpy.logspace

numpy.logspace 函数用于创建一个于等比数列。格式如下：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

base 参数意思是取对数的时候 log 的下标。

实例

import numpy as np
# 默认底数是 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 :

实例

import numpy as np
a = np.logspace(0,9,10,base=2)
print (a)

输出如下：

[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

七、numpy对数组的操作

　　1、NumPy 切片和索引

　　　　ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。

　　　　ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

　　　　实例

import numpy as np
a = np.arange(10)
s = slice(2,7,2)
# 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])

输出结果为：

[2  4  6]

　　以上实例中，我们首先通过 arange() 函数创建 ndarray 对象。 然后，分别设置起始，终止和步长的参数为 2，7 和 2。

　　我们也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：

　　　　实例

import numpy as np
a = np.arange(10)
b = a[2:7:2]
# 从索引 2 开始到索引 7 停止，间隔为 2
print(b)

输出结果为：

[2  4  6]

　　冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

　　　　实例

import numpy as np
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9] b = a[5]
print(b)

输出结果为：

5

　　　　实例

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

输出结果为：

[2  3  4  5  6  7  8  9]

　　　　实例

import numpy as np
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
print(a[2:5])

输出结果为：

[2  3  4]

多维数组同样适用上述索引提取方法：

　　　　实例

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a) # 从某个索引处开始切割 print(\'从数组索引 a[1:] 处开始切割\') print(a[1:])

输出结果为：

[[1 2 3]
 [3 4 5]
 [4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5]
 [4 5 6]]

切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

　　　　实例

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1])
# 第2列元素 print (a[1,...]) # 第2行元素 print (a[...,1:]) # 第2列及剩下的所有元素

输出结果为：

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

　　2、NumPy 广播(Broadcast)

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。

如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

实例

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]

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如：

实例

import numpy as np
a = np.array([[ 0, 0, 0], [10,10,10], [20,20,20], [30,30,30]])
b = np.array([1,2,3])
print(a + b)

输出结果为：

[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

实例

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
bb = np.tile(b, (4, 1))  # 重复 b 的各个维度
print(a + bb)

输出结果为：

[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

　　3、NumPy 迭代数组

　　　　NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。

　　　　迭代器最基本的任务的可以完成对数组元素的访问。

　　　　接下来我们使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代。

　　实例

import numpy as np
a = np.arange(6).reshape(2,3)
print (\'原始数组是：\')
print (a) print (\'\\n\')
print (\'迭代输出元素：\')
for x in np.nditer(a):
　　print (x, end=\", \" )
print (\'\\n\')

输出结果为：

原始数组是：
[[0 1 2]
 [3 4 5]]


迭代输出元素：
0, 1, 2, 3, 4, 5,

　　控制遍历顺序

　　　　for x in np.nditer(a, order=\'F\'):Fortran order，即是列序优先；

　　　　for x in np.nditer(a.T, order=\'C\'):C order，即是行序优先；

import numpy as np
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print (\'原始数组是：\') 
print (a) 
print (\'\\n\') 
print (\'原始数组的转置是：\') 
b = a.T 
print (b) 
print (\'\\n\') 
print (\'以 C 风格顺序排序：\') 
c = b.copy(order=\'C\')  
print (c)
for x in np.nditer(c):  
    print (x, end=\", \" )
print  (\'\\n\') 
print  (\'以 F 风格顺序排序：\')
c = b.copy(order=\'F\')  
print (c)
for x in np.nditer(c):  
    print (x, end=\", \" )

　　4、数组操作

numpy.reshape

numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下：

numpy.reshape(arr, newshape, order=\'C\')

• arr：要修改形状的数组
• newshape：整数或者整数数组，新的形状应当兼容原有形状
• order：\'C\' -- 按行，\'F\' -- 按列，\'A\' -- 原顺序，\'k\' -- 元素在内存中的出现顺序。

实例

import numpy as np
a = np.arange(8) print (\'原始数组：\')
print (a)
print (\'\\n\')
b = a.reshape(4,2)
print (\'修改后的数组：\')
print (b)

numpy.ndarray.flat

numpy.ndarray.flat 是一个数组元素迭代器，实例如下:

实例

import numpy as np
a = np.arange(9).reshape(3,3)
print (\'原始数组：\')
for row in a:
　　print (row)
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print (\'迭代后的数组：\')
for element in a.flat:
　　print (element)

numpy.ndarray.flatten

numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：

ndarray.flatten(order=\'C\')

参数说明：

• order：\'C\' -- 按行，\'F\' -- 按列，\'A\' -- 原顺序，\'K\' -- 元素在内存中的出现顺序。

实例

import numpy as np
a = np.arange(8).reshape(2,4)
print (\'原数组：\')
print (a)
print (\'\\n\')
# 默认按行
print (\'展开的数组：\')
print (a.flatten())
print (\'\\n\')
print (\'以 F 风格顺序展开的数组：\')
print (a.flatten(order = \'F\'))

numpy.ravel

numpy.ravel() 展平的数组元素，顺序通常是\"C风格\"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。

该函数接收两个参数：

numpy.ravel(a, order=\'C\')

参数说明：

• order：\'C\' -- 按行，\'F\' -- 按列，\'A\' -- 原顺序，\'K\' -- 元素在内存中的出现顺序。

实例

import numpy as np
a = np.arange(8).reshape(2,4)
print (\'原数组：\')
print (a)
print (\'\\n\')
print (\'调用 ravel 函数之后：\')
print (a.ravel())
print (\'\\n\')
print (\'以 F 风格顺序调用 ravel 函数之后：\')
print (a.ravel(order = \'F\'))

numpy.transpose

numpy.transpose 函数用于对换数组的维度，格式如下：

numpy.transpose(arr, axes)

参数说明:

• arr：要操作的数组
• axes：整数列表，对应维度，通常所有维度都会对换。

实例

import numpy as np
a = np.arange(12).reshape(3,4)
print (\'原数组：\')
print (a )
print (\'\\n\')
print (\'对换数组：\')
print (np.transpose(a))

numpy.rollaxis

numpy.rollaxis 函数向后滚动特定的轴到一个特定位置，格式如下：

numpy.rollaxis(arr, axis, start)

参数说明：

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

实例

import numpy as np
 
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
 
print (\'原数组：\')
print (a)
print (\'获取数组中一个值：\')
print(np.where(a==6))   
print(a[1,1,0])  # 为 6
print (\'\\n\')
 
 
# 将轴 2 滚动到轴 0（宽度到深度）
 
print (\'调用 rollaxis 函数：\')
b = np.rollaxis(a,2,0)
print (b)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [0, 1, 1]
# 最后一个 0 移动到最前面
print(np.where(b==6))   
print (\'\\n\')
 
# 将轴 2 滚动到轴 1：（宽度到高度）
 
print (\'调用 rollaxis 函数：\')
c = np.rollaxis(a,2,1)
print (c)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [1, 0, 1]
# 最后的 0 和 它前面的 1 对换位置
print(np.where(c==6))   
print (\'\\n\')

numpy.swapaxes

numpy.swapaxes 函数用于交换数组的两个轴，格式如下：

numpy.swapaxes(arr, axis1, axis2)

• arr：输入的数组
• axis1：对应第一个轴的整数
• axis2：对应第二个轴的整数

实例

import numpy as np
 
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
 
print (\'原数组：\')
print (a)
print (\'\\n\')
# 现在交换轴 0（深度方向）到轴 2（宽度方向）
 
print (\'调用 swapaxes 函数后的数组：\')
print (np.swapaxes(a, 2, 0))

numpy.broadcast

numpy.broadcast 用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。

该函数使用两个数组作为输入参数，如下实例：

实例

import numpy as np
 
x = np.array([[1], [2], [3]])
y = np.array([4, 5, 6])  
 
# 对 y 广播 x
b = np.broadcast(x,y)  
# 它拥有 iterator 属性，基于自身组件的迭代器元组
 
print (\'对 y 广播 x：\')
r,c = b.iters
 
# Python3.x 为 next(context) ，Python2.x 为 context.next()
print (next(r), next(c))
print (next(r), next(c))
print (\'\\n\')
# shape 属性返回广播对象的形状
 
print (\'广播对象的形状：\')
print (b.shape)
print (\'\\n\')
# 手动使用 broadcast 将 x 与 y 相加
b = np.broadcast(x,y)
c = np.empty(b.shape)
 
print (\'手动使用 broadcast 将 x 与 y 相加：\')
print (c.shape)
print (\'\\n\')
c.flat = [u + v for (u,v) in b]
 
print (\'调用 flat 函数：\')
print (c)
print (\'\\n\')
# 获得了和 NumPy 内建的广播支持相同的结果
 
print (\'x 与 y 的和：\')
print (x + y)

numpy.broadcast_to

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

numpy.broadcast_to(array, shape, subok)

实例

import numpy as np
 
a = np.arange(4).reshape(1,4)
 
print (\'原数组：\')
print (a)
print (\'\\n\')
 
print (\'调用 broadcast_to 函数之后：\')
print (np.broadcast_to(a,(4,4)))

numpy.expand_dims

numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状，函数格式如下:

 numpy.expand_dims(arr, axis)

参数说明：

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

实例

import numpy as np
 
x = np.array(([1,2],[3,4]))
 
print (\'数组 x：\')
print (x)
print (\'\\n\')
y = np.expand_dims(x, axis = 0)
 
print (\'数组 y：\')
print (y)
print (\'\\n\')
 
print (\'数组 x 和 y 的形状：\')
print (x.shape, y.shape)
print (\'\\n\')
# 在位置 1 插入轴
y = np.expand_dims(x, axis = 1)
 
print (\'在位置 1 插入轴之后的数组 y：\')
print (y)
print (\'\\n\')
 
print (\'x.ndim 和 y.ndim：\')
print (x.ndim,y.ndim)
print (\'\\n\')
 
print (\'x.shape 和 y.shape：\')
print (x.shape, y.shape)

numpy.squeeze

numpy.squeeze 函数从给定数组的形状中删除一维的条目，函数格式如下：

numpy.squeeze(arr, axis)

参数说明：

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

实例

import numpy as np
 
x = np.arange(9).reshape(1,3,3)
 
print (\'数组 x：\')
print (x)
print (\'\\n\')
y = np.squeeze(x)
 
print (\'数组 y：\')
print (y)
print (\'\\n\')
 
print (\'数组 x 和 y 的形状：\')
print (x.shape, y.shape)

numpy.concatenate

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：

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

参数说明：

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

实例

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print (\'第一个数组：\')
print (a)
print (\'\\n\')
b = np.array([[5,6],[7,8]])
 
print (\'第二个数组：\')
print (b)
print (\'\\n\')
# 两个数组的维度相同
 
print (\'沿轴 0 连接两个数组：\')
print (np.concatenate((a,b)))
print (\'\\n\')
 
print (\'沿轴 1 连接两个数组：\')
print (np.concatenate((a,b),axis = 1))

numpy.split

numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：

numpy.split(ary, indices_or_sections, axis)

参数说明：

• ary：被分割的数组
• indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
• axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。

实例

import numpy as np
 
a = np.arange(9)
 
print (\'第一个数组：\')
print (a)
print (\'\\n\')
 
print (\'将数组分为三个大小相等的子数组：\')
b = np.split(a,3)
print (b)
print (\'\\n\')
 
print (\'将数组在一维数组中表明的位置分割：\')
b = np.split(a,[4,7])
print (b)

numpy.resize

numpy.resize 函数返回指定大小的新数组。

如果新数组大小大于原始大小，则包含原始数组中的元素的副本。

numpy.resize(arr, shape)

参数说明：

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

实例

import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
 
print (\'第一个数组：\')
print (a)
print (\'\\n\')
 
print (\'第一个数组的形状：\')
print (a.shape)
print (\'\\n\')
b = np.resize(a, (3,2))
 
print (\'第二个数组：\')
print (b)
print (\'\\n\')
 
print (\'第二个数组的形状：\')
print (b.shape)
print (\'\\n\')
# 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了
 
print (\'修改第二个数组的大小：\')
b = np.resize(a,(3,3))
print (b)

numpy.append

numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。

append 函数返回的始终是一个一维数组。

numpy.append(arr, values, axis=None)

参数说明：

• arr：输入数组
• values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
• axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。

实例

import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
 
print (\'第一个数组：\')
print (a)
print (\'\\n\')
 
print (\'向数组添加元素：\')
print (np.append(a, [7,8,9]))
print (\'\\n\')
 
print (\'沿轴 0 添加元素：\')
print (np.append(a, [[7,8,9]],axis = 0))
print (\'\\n\')
 
print (\'沿轴 1 添加元素：\')
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))

numpy.delete

numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

Numpy.delete(arr, obj, axis)

参数说明：

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

实例

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print (\'第一个数组：\')
print (a)
print (\'\\n\')
 
print (\'未传递 Axis 参数。 在插入之前输入数组会被展开。\')
print (np.delete(a,5))
print (\'\\n\')
 
print (\'删除第二列：\')
print (np.delete(a,1,axis = 1))
print (\'\\n\')
 
print (\'包含从数组中删除的替代值的切片：\')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))

numpy.unique

numpy.unique 函数用于去除数组中的重复元素。

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

• arr：输入数组，如果不是一维数组则会展开
• return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
• return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
• return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

实例

import numpy as np
 
a = np.array([5,2,6,2,7,5,6,8,2,9])
 
print (\'第一个数组：\')
print (a)
print (\'\\n\')
 
print (\'第一个数组的去重值：\')
u = np.unique(a)
print (u)
print (\'\\n\')
 
print (\'去重数组的索引数组：\')
u,indices = np.unique(a, return_index = True)
print (indices)
print (\'\\n\')
 
print (\'我们可以看到每个和原数组下标对应的数值：\')
print (a)
print (\'\\n\')
 
print (\'去重数组的下标：\')
u,indices = np.unique(a,return_inverse = True)
print (u)
print (\'\\n\')
 
print (\'下标为：\')
print (indices)
print (\'\\n\')
 
print (\'使用下标重构原数组：\')
print (u[indices])
print (\'\\n\')
 
print (\'返回去重元素的重复数量：\')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)

八、numpy函数

　　1、NumPy 字符串函数

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

这些函数在字符数组类（numpy.char）中定义。

numpy.char.add()

numpy.char.add() 函数依次对两个数组的元素进行字符串连接。

实例

import numpy as np 
 
print (\'连接两个字符串：\')
print (np.char.add([\'hello\'],[\' xyz\']))
print (\'\\n\')
 
print (\'连接示例：\')
print (np.char.add([\'hello\', \'hi\'],[\' abc\', \' xyz\']))

numpy.char.multiply()

numpy.char.multiply() 函数执行多重连接。

实例

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

numpy.char.center()

numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。

实例

import numpy as np 
 
# np.char.center(str , width,fillchar) ：
# str: 字符串，width: 长度，fillchar: 填充字符
print (np.char.center(\'Runoob\', 20,fillchar = \'*\'))

numpy.char.capitalize()

numpy.char.capitalize() 函数将字符串的第一个字母转换为大写：

实例

import numpy as np 
 
print (np.char.capitalize(\'runoob\'))

numpy.char.title()

numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写：

实例

import numpy as np
 
print (np.char.title(\'i like runoob\'))

numpy.char.lower()

numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。

实例

import numpy as np 
 
#操作数组
print (np.char.lower([\'RUNOOB\',\'GOOGLE\']))
 
# 操作字符串
print (np.char.lower(\'RUNOOB\'))

numpy.char.upper()

numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper。

实例

import numpy as np 
 
#操作数组
print (np.char.upper([\'runoob\',\'google\']))
 
# 操作字符串
print (np.char.upper(\'runoob\'))

numpy.char.split()

numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。

实例

import numpy as np 
 
# 分隔符默认为空格
print (np.char.split (\'i like runoob?\'))
# 分隔符为 .
print (np.char.split (\'www.runoob.com\', sep = \'.\'))

numpy.char.splitlines()

numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。

实例

import numpy as np 
 
# 换行符 \\n
print (np.char.splitlines(\'i\\nlike runoob?\')) 
print (np.char.splitlines(\'i\\rlike runoob?\'))

numpy.char.strip()

numpy.char.strip() 函数用于移除开头或结尾处的特定字符。

实例

import numpy as np 
 
# 移除字符串头尾的 a 字符
print (np.char.strip(\'ashok arunooba\',\'a\'))
 
# 移除数组元素头尾的 a 字符
print (np.char.strip([\'arunooba\',\'admin\',\'java\'],\'a\'))

numpy.char.join()

numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串

实例

import numpy as np 
 
# 操作字符串
print (np.char.join(\':\',\'runoob\'))
 
# 指定多个分隔符操作数组元素
print (np.char.join([\':\',\'-\'],[\'runoob\',\'google\']))

numpy.char.replace()

numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。

实例

import numpy as np 
 
print (np.char.replace (\'i like runoob\', \'oo\', \'cc\'))

numpy.char.encode()

numpy.char.encode() 函数对数组中的每个元素调用 str.encode 函数。 默认编码是 utf-8，可以使用标准 Python 库中的编解码器。

实例

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

numpy.char.decode()

numpy.char.decode() 函数对编码的元素进行 str.decode() 解码。

实例

import numpy as np 
 
a = np.char.encode(\'runoob\', \'cp500\') 
print (a)
print (np.char.decode(a,\'cp500\'))

　　2、NumPy 数学函数

　　NumPy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。

　　三角函数（详情：https://www.runoob.com/numpy/numpy-mathematical-functions.html）

　　NumPy 提供了标准的三角函数：sin()、cos()、tan()。

实例

import numpy as np
 
a = np.array([0,30,45,60,90])
print (\'不同角度的正弦值：\')
# 通过乘 pi/180 转化为弧度  
print (np.sin(a*np.pi/180))
print (\'\\n\')
print (\'数组中角度的余弦值：\')
print (np.cos(a*np.pi/180))
print (\'\\n\')
print (\'数组中角度的正切值：\')
print (np.tan(a*np.pi/180))

函数    描述
add()    对两个数组的逐个字符串元素进行连接
multiply()    返回按元素多重连接后的字符串
center()    居中字符串
capitalize()    将字符串第一个字母转换为大写
title()    将字符串的每个单词的第一个字母转换为大写
lower()    数组元素转换为小写
upper()    数组元素转换为大写
split()    指定分隔符对字符串进行分割，并返回数组列表
splitlines()    返回元素中的行列表，以换行符分割
strip()    移除元素开头或者结尾处的特定字符
join()    通过指定分隔符来连接数组中的元素
replace()    使用新字符串替换字符串中的所有子字符串
decode()    数组元素依次调用str.decode
encode()    数组元素依次调用str.encode

舍入函数

numpy.around() 函数返回指定数字的四舍五入值。

numpy.around(a,decimals)

参数说明：

• a: 数组
• decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

实例

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

numpy.floor()

numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。

实例

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

numpy.ceil()

numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。

实例

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

　　3、NumPy 算术函数

　　NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。

　　需要注意的是数组必须具有相同的形状或符合数组广播规则。

import numpy as np 
 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print (\'第一个数组：\')
print (a)
print (\'\\n\')
print (\'第二个数组：\')
b = np.array([10,10,10])  
print (b)
print (\'\\n\')
print (\'两个数组相加：\')
print (np.add(a,b))
print (\'\\n\')
print (\'两个数组相减：\')
print (np.subtract(a,b))
print (\'\\n\')
print (\'两个数组相乘：\')
print (np.multiply(a,b))
print (\'\\n\')
print (\'两个数组相除：\')
print (np.divide(a,b))

此外 Numpy 也包含了其他重要的算术函数。

numpy.reciprocal()

numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。

#实例
import numpy as np 
 
a = np.array([0.25,  1.33,  1,  100])  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'调用 reciprocal 函数：\')
print (np.reciprocal(a))

numpy.power()

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

实例

import numpy as np 
 
a = np.array([10,100,1000])  
print (\'我们的数组是；\')
print (a)
print (\'\\n\') 
print (\'调用 power 函数：\')
print (np.power(a,2))
print (\'\\n\')
print (\'第二个数组：\')
b = np.array([1,2,3])  
print (b)
print (\'\\n\')
print (\'再次调用 power 函数：\')
print (np.power(a,b))

numpy.mod()

numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

实例

import numpy as np
 
a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print (\'第一个数组：\')
print (a)
print (\'\\n\')
print (\'第二个数组：\')
print (b)
print (\'\\n\')
print (\'调用 mod() 函数：\')
print (np.mod(a,b))
print (\'\\n\')
print (\'调用 remainder() 函数：\')
print (np.remainder(a,b))

　　4、NumPy 统计函数

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

numpy.amin() 和 numpy.amax()

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

案例

import numpy as np 
 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'调用 amin() 函数：\')
print (np.amin(a,1))
print (\'\\n\')
print (\'再次调用 amin() 函数：\')
print (np.amin(a,0))
print (\'\\n\')
print (\'调用 amax() 函数：\')
print (np.amax(a))
print (\'\\n\')
print (\'再次调用 amax() 函数：\')
print (np.amax(a, axis =  0))

numpy.ptp()

numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

实例

import numpy as np 
 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'调用 ptp() 函数：\')
print (np.ptp(a))
print (\'\\n\')
print (\'沿轴 1 调用 ptp() 函数：\')
print (np.ptp(a, axis =  1))
print (\'\\n\')
print (\'沿轴 0 调用 ptp() 函数：\')
print (np.ptp(a, axis =  0))

numpy.percentile()

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

numpy.percentile(a, q, axis)

参数说明：

• a: 输入数组
• q: 要计算的百分位数，在 0 ~ 100 之间
• axis: 沿着它计算百分位数的轴

首先明确百分位数：

第 p 个百分位数是这样一个值，它使得至少有 p% 的数据项小于或等于这个值，且至少有 (100-p)% 的数据项大于或等于这个值。

举个例子：高等院校的入学考试成绩经常以百分位数的形式报告。比如，假设某个考生在入学考试中的语文部分的原始分数为 54 分。相对于参加同一考试的其他学生来说，他的成绩如何并不容易知道。但是如果原始分数54分恰好对应的是第70百分位数，我们就能知道大约70%的学生的考分比他低，而约30%的学生考分比他高。

这里的 p = 70。

实例

import numpy as np 
 
a = np.array([[10, 7, 4], [3, 2, 1]])
print (\'我们的数组是：\')
print (a)
 
print (\'调用 percentile() 函数：\')
# 50% 的分位数，就是 a 里排序之后的中位数
print (np.percentile(a, 50)) 
 
# axis 为 0，在纵列上求
print (np.percentile(a, 50, axis=0)) 
 
# axis 为 1，在横行上求
print (np.percentile(a, 50, axis=1)) 
 
# 保持维度不变
print (np.percentile(a, 50, axis=1, keepdims=True))

numpy.median()

numpy.median() 函数用于计算数组 a 中元素的中位数（中值）

实例

import numpy as np 
 
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'调用 median() 函数：\')
print (np.median(a))
print (\'\\n\')
print (\'沿轴 0 调用 median() 函数：\')
print (np.median(a, axis =  0))
print (\'\\n\')
print (\'沿轴 1 调用 median() 函数：\')
print (np.median(a, axis =  1))

numpy.mean()

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

算术平均值是沿轴的元素的总和除以元素的数量。

实例

import numpy as np 
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'调用 mean() 函数：\')
print (np.mean(a))
print (\'\\n\')
print (\'沿轴 0 调用 mean() 函数：\')
print (np.mean(a, axis =  0))
print (\'\\n\')
print (\'沿轴 1 调用 mean() 函数：\')
print (np.mean(a, axis =  1))

numpy.average()

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

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

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

实例

import numpy as np 
 
a = np.array([1,2,3,4])  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'调用 average() 函数：\')
print (np.average(a))
print (\'\\n\')
# 不指定权重时相当于 mean 函数
wts = np.array([4,3,2,1])  
print (\'再次调用 average() 函数：\')
print (np.average(a,weights = wts))
print (\'\\n\')
# 如果 returned 参数设为 true，则返回权重的和  
print (\'权重的和：\')
print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))

　　5、NumPy 排序、条件刷选函数

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

numpy.sort()

numpy.sort() 函数返回输入数组的排序副本。函数格式如下：

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

参数说明：

• a: 要排序的数组
• axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
• kind: 默认为\'quicksort\'（快速排序）
• order: 如果数组包含字段，则是要排序的字段

实例

import numpy as np  
 
a = np.array([[3,7],[9,1]])  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'调用 sort() 函数：\')
print (np.sort(a))
print (\'\\n\')
print (\'按列排序：\')
print (np.sort(a, axis =  0))
print (\'\\n\')
# 在 sort 函数中排序字段 
dt = np.dtype([(\'name\',  \'S10\'),(\'age\',  int)]) 
a = np.array([(\"raju\",21),(\"anil\",25),(\"ravi\",  17),  (\"amar\",27)], dtype = dt)  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'按 name 排序：\')
print (np.sort(a, order =  \'name\'))

numpy.argsort()

numpy.argsort() 函数返回的是数组值从小到大的索引值。

实例

import numpy as np 
 
x = np.array([3,  1,  2])  
print (\'我们的数组是：\')
print (x)
print (\'\\n\')
print (\'对 x 调用 argsort() 函数：\')
y = np.argsort(x)  
print (y)
print (\'\\n\')
print (\'以排序后的顺序重构原数组：\')
print (x[y])
print (\'\\n\')
print (\'使用循环重构原数组：\')
for i in y:  
    print (x[i], end=\" \")

numpy.lexsort()

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

这里举一个应用场景：小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取…… 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第三列。

实例

import numpy as np 
 
nm =  (\'raju\',\'anil\',\'ravi\',\'amar\') 
dv =  (\'f.y.\',  \'s.y.\',  \'s.y.\',  \'f.y.\') 
ind = np.lexsort((dv,nm))  
print (\'调用 lexsort() 函数：\') 
print (ind) 
print (\'\\n\') 
print (\'使用这个索引来获取排序后的数据：\') 
print ([nm[i]  +  \", \"  + dv[i]  for i in ind])

numpy.nonzero()

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

实例

import numpy as np 
 
a = np.array([[30,40,0],[0,20,10],[50,0,60]])  
print (\'我们的数组是：\')
print (a)
print (\'\\n\')
print (\'调用 nonzero() 函数：\')
print (np.nonzero (a))

numpy.where()

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

实例

import numpy as np 
 
x = np.arange(9.).reshape(3,  3)  
print (\'我们的数组是：\')
print (x)
print ( \'大于 3 的元素的索引：\')
y = np.where(x >  3)  
print (y)
print (\'使用这些索引来获取满足条件的元素：\')
print (x[y])

numpy.extract()

numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。

实例

import numpy as np 
 
x = np.arange(9.).reshape(3,  3)  
print (\'我们的数组是：\')
print (x)
# 定义条件, 选择偶数元素
condition = np.mod(x,2)  ==  0  
print (\'按元素的条件值：\')
print (condition)
print (\'使用条件提取元素：\')
print (np.extract(condition, x))

全文来自：https://www.runoob.com/numpy/numpy-tutorial.html

来源：https://www.cnblogs.com/zzc1102/p/16186302.html
本站部分图文来源于网络，如有侵权请联系删除。