文章目录
1 Numpy先知
NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：
- 一个强大的N维数组对象 ndarray
- 广播功能函数
- 整合 C/C++/Fortran 代码的工具
- 线性代数、傅里叶变换、随机数生成等功能
2 Ndarray 对象
ndarray是N 维数，是NumPy 最重要的一个特点。它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
ndarray 对象是用于存放同类型元素的多维数组。
ndarray 中的每个元素在内存中都有相同存储大小的区域。
创建一个 ndarray 只需调用 NumPy 的 array 函数即可：
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
示例：
#实例 1
import numpy as np
a = np.array([1,2,3])
print (a)
#输出结果如下：
[1 2 3]
#实例 2
# 多于一个维度
import numpy as np
a = np.array([[1, 2], [3, 4]])
print (a)
#输出结果如下：
[[1 2]
[3 4]]
#实例 3
# 最小维度
import numpy as np
a = np.array([1, 2, 3, 4, 5], ndmin = 2)
print (a)
#输出如下：(2维数组)
[[1 2 3 4 5]]
#实例 4
# dtype 参数
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print (a)
#输出结果如下：
[1.+0.j 2.+0.j 3.+0.j]
3 NumPy 数据类型
常用 NumPy 基本类型
| 名称 | 描述 |
|---|---|
| bool_ | 布尔型数据类型（True 或者 False） |
| int_ | 默认的整数类型（类似于 C 语言中的 long，int32 或 int64） |
| intc | 与 C 的 int 类型一样，一般是 int32 或 int 64 |
| intp | 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64） |
| int8 | 字节（-128 to 127） |
| int16 | 整数（-32768 to 32767） |
| int32 | 整数（-2147483648 to 2147483647） |
| int64 | 整数（-9223372036854775808 to 9223372036854775807） |
| uint8 | 无符号整数（0 to 255） |
| uint16 | 无符号整数（0 to 65535） |
| uint32 | 无符号整数（0 to 4294967295） |
| uint64 | 无符号整数（0 to 18446744073709551615） |
| float_ | float64 类型的简写 |
| float16 | 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位 |
| float32 | 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位 |
| float64 | 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位 |
| complex_ | complex128 类型的简写，即 128 位复数 |
| complex64 | 复数，表示双 32 位浮点数（实数部分和虚数部分） |
| complex128 | 复数，表示双 64 位浮点数（实数部分和虚数部分） |
数据类型对象 (dtype)
numpy.dtype(object, align, copy)
| 属性 | 描述 |
|---|---|
| object | 要转换为的数据类型对象 |
| align | 如果为 true，填充字段使其类似 C 的结构体。 |
| copy | 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用 |
它描述了数据的以下几个方面：
- 数据的类型（整数，浮点数或者 Python 对象）
- 数据的大小（例如， 整数使用多少个字节存储）
- 数据的字节顺序（小端法或大端法）
- 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
- 如果数据类型是子数组，那么它的形状和数据类型是什么。
示例：
#实例 1
import numpy as np
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt = np.dtype('i4')
print(dt)
#输出结果为：
int32
#实例 2
import numpy as np
# 字节顺序标注
dt = np.dtype('<i4')
print(dt)
#输出结果为：
int32
#实例 3
# 将数据类型应用于 ndarray 对象
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print(a)
#输出结果为：
[(10,) (20,) (30,)]
#实例 4
# 类型字段名可以用于存取实际的 age 列
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print(a['age'])
#输出结果为：
[10 20 30]
4 NumPy 数组属性
- NumPy 数组的维数称为秩（rank），即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。
- axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。
- 在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。
NumPy 的数组中比较重要 ndarray 对象属性有：
| 属性 | 说明 |
|---|---|
| ndarray.ndim | 秩，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 |
| ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |
| ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 |
| ndarray.flags | ndarray 对象的内存信息 |
| ndarray.real | ndarray元素的实部 |
| ndarray.imag | ndarray 元素的虚部 |
| ndarray.data | 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 |
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 也可以用于调整数组大小。
实例
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print (a.shape)
#输出结果为：
(2, 3)
#调整数组大小。
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]]
#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.itemsize
ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。
例如，一个元素类型为 float64 的数组 itemsize 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。
实例
import numpy as np
# 数组的 dtype 为 int8（一个字节）
x = np.array([1,2,3,4,5], dtype = np.int8)
print (x.itemsize)
# 数组的 dtype 现在为 float64（八个字节）
y = np.array([1,2,3,4,5], dtype = np.float64)
print (y.itemsize)
#输出结果为：
1
8
5 NumPy 创建数组
ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。
5.1 使用empty zeros ones创建
numpy.empty
numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：
numpy.empty(shape, dtype = float, order = 'C')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
下面是一个创建空数组的实例：
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')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |
实例
import numpy as np
# 默认为浮点数
x = np.zeros(5)
print(x)
# 设置类型为整数
y = np.zeros((5,), dtype = 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')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |
实例
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]]
5.2 从已有的数组创建数组
numpy.asarray
numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。
numpy.asarray(a, dtype = None, order = None)
参数说明：
| 参数 | 描述 |
|---|---|
| a | 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 |
| dtype | 数据类型，可选 |
| order | 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
#将列表转换为 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.frombuffer
numpy.frombuffer 用于实现动态数组。
numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
注意：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。
参数说明：
| 参数 | 描述 |
|---|---|
| buffer | 可以是任意对象，会以流的形式读入。 |
| dtype | 返回数组的数据类型，可选 |
| count | 读取的数据数量，默认为-1，读取所有数据。 |
| offset | 读取的起始位置，默认为0。 |
Python3.x 实例
import numpy as np
s = b'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print (a)
#输出结果为：
[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
Python2.x 实例
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
numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。
numpy.fromiter(iterable, dtype, count=-1)
| 参数 | 描述 |
|---|---|
| iterable | 可迭代对象 |
| dtype | 返回数组的数据类型 |
| count | 读取的数据数量，默认为-1，读取所有数据 |
实例
import numpy as np
# 使用 range 函数创建列表对象
list=range(5)
it=iter(list)
# 使用迭代器创建 ndarray
x=np.fromiter(it, dtype=float)
print(x)
#输出结果为：
[0. 1. 2. 3. 4.]
5.3 从数值范围创建数组
numpy.arange
numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：
numpy.arange(start, stop, step, dtype)
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
参数说明：
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为0 |
| stop | 终止值（不包含） |
| step | 步长，默认为1 |
| dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
#生成 0 到 4 长度为 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)
参数说明：
| 参数 | 描述 |
|---|---|
| start | 序列的起始值 |
| stop | 序列的终止值，如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 |
| retstep | 如果为 True 时，生成的数组中会显示间距，反之不显示。 |
| dtype | ndarray 的数据类型 |
#以下实例用到三个参数，设置起始点为 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.]
#设置元素全部是1的等差数列：
#实例
import numpy as np
a = np.linspace(1,1,10)
print(a)
#输出结果为：
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
#将 endpoint 设为 false，不包含终止值：
#实例
import numpy as np
a = np.linspace(10, 20, 5, endpoint = False)
print(a)
#输出结果为：
[10. 12. 14. 16. 18.]
#如果将 endpoint 设为 true，则会包含 20。
#以下实例设置间距。
#实例
import numpy as np
a =np.linspace(1,10,10,retstep= True)
print(a)
#拓展例子
b =np.linspace(1,10,10).reshape([10,1])
print(b)
#输出结果为：
(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
[[ 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 的下标。
| 参数 | 描述 |
|---|---|
| start | 序列的起始值为：base ** start |
| stop | 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。 |
| base | 对数 log 的底数。 |
| dtype | ndarray 的数据类型 |
实例
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.]
6 切片和索引
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]
也可以通过冒号分隔切片参数 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]]
7 高级索引
NumPy 中的高级索引指的是
使用整数数组、布尔数组或者其他序列来访问数组的元素。相比于基本索引，高级索引可以访问到数组中的任意元素，并且可以用来对数组进行复杂的操作和修改。
整数数组索引
整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。
以下实例获取数组中 (0,0)，(1,1) 和 (2,0) 位置处的元素。
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]
以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print ('我们的数组是：' )
print (x)
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print ('这个数组的四个角元素是：')
print (y)
#输出结果为：
我们的数组是：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
这个数组的四个角元素是：
[[ 0 2]
[ 9 11]]
返回的结果是包含每个角元素的 ndarray 对象。可以借助切片 : 或 … 与索引数组组合。
import numpy as np
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(a)
print("==========")
print(b)
print("==========")
print(c)
print("==========")
print(d)
#输出结果为：
[[1 2 3]
[4 5 6]
[7 8 9]]
==========
[[5 6]
[8 9]]
==========
[[5 6]
[8 9]]
==========
[[2 3]
[5 6]
[8 9]]
布尔索引
我们可以通过一个布尔数组来索引目标数组。
布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
以下实例获取大于 5 的元素：
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print ('我们的数组是：')
print (x)
print ('\n')
#现在我们会打印出大于 5 的元素
print ('大于 5 的元素是：')
print (x[x > 5])
#输出结果为：
我们的数组是：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
大于 5 的元素是：
[ 6 7 8 9 10 11]
以下实例使用了 ~（取补运算符）来过滤 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.]
以下实例演示如何从数组中过滤掉非复数元素。
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]
花式索引
花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。
对于使用一维整型数组作为索引:如果目标是一维数组，那么索引的结果就是对应位置的元素;
如果目标是二维数组，那么就是对应下标的行。花式索引跟切片不一样，它总是将数据复制到新数组中。
一维数组
一维数组只有一个轴 axis = 0，所以一维数组就在 axis = 0 这个轴上取值：
import numpy as np
x = np.arange(9)
print(x)
#一维数组读取指定下标对应的元素
print("-------读取下标对应的元素-------")
x2 = x[[0, 6]] # 使用花式索引
print(x2)
print(x2[0])
print(x2[1])
#输出结果为：
[0 1 2 3 4 5 6 7 8]
-------读取下标对应的元素-------
[0 6]
0
6
二维数组
1、传入顺序索引数组
import numpy as np
x=np.arange(32).reshape((8,4))
print(x)
#二维数组读取指定下标对应的行
print("-------读取下标对应的行-------")
#输出下表为 4, 2, 1, 7 对应的行
print (x[[4,2,1,7]])
print("==========")
#输出（1,1）位置的值
print (x[[1],[1]])
print("==========")
#输出（1,1），（3,1）位置的值
print (x[[1,3],[1]])
print("==========")
#输出（1,1），（3,2）位置的值
print (x[[1,3],[1,2]])
#输出结果为：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
-------读取下标对应的行-------
[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
==========
[5]
==========
[ 5 13]
==========
[ 5 14]
2、传入倒序索引数组
import numpy as np
x=np.arange(32).reshape((8,4))
print (x[[-4,-2,-1,-7]])
#输出结果为：
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
3、传入多个索引数组（要使用 np.ix_）
np.ix_ 函数就是输入两个数组，产生笛卡尔积的映射关系。
笛卡尔乘积是指在数学中，两个集合 X 和 Y 的笛卡尔积（Cartesian product），又称直积，表示为 X×Y，第一个对象是X的成员而第二个对象是 Y 的所有可能有序对的其中一个成员。
例如 A={a,b}, B={0,1,2}，则：
A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}
B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}
import numpy as np
x=np.arange(32).reshape((8,4))
print(x)
print(" ==========")
print (x[np.ix_([1,5,7,2],[0,3,1,2])])
#输出结果为：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
==========
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
8 广播(Broadcast)
广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同(行列数相同)，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。
广播的规则:
- 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
- 输出数组的形状是输入数组形状的各个维度上的最大值。
- 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
- 当输入数组的某个维度的长度为 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]
2 个数组的形状不同时，numpy 将自动触发广播机制
4x3 的二维数组与长为 3 的一维数组相加，等效于把数组 b 在二维上重复 4 次再运算。
下例为自动触发广播机制
import numpy as np
a = np.array([[ 0, 0, 0],
[10,10,10],
[20,20,20],
[30,30,30]])
b = np.array([0,1,2])
print(a + b)
#输出结果为：
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]
主动将数组 b 在二维上重复 4 次，在参与运算
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]]
np.tile()函数的作用
平铺复制，依据参数的值和个数，对其对应位置进行复制对应倍数。
例：如果扩大倍数只有一个，默认为X轴（行），如果值为1，就是原样子不变
np.tile(a,(2))的作用就是将a数组沿着X轴扩大两倍（也可写作np.tile(a,2)）
import numpy as np
a=np.array([
[1,2,3],
[4,5,6]
])
#将数组a在x轴（行方向上扩展二倍）
b=np.tile(a,2) #b=np.tile(a,(2))
print(b)
#输出结果
[[1 2 3 1 2 3]
[4 5 6 4 5 6]]
例：如果有两个参数（行，列）第一个参数为Y轴（行）扩展倍数，第二个为X轴（列）扩展倍数。
np.tile(a,(2,1))的作用就是将a数组沿着y轴（行）扩展两倍，沿x轴（列）扩展一倍（列原样，仍3列）
import numpy as np
a=np.array([
[1,2,3],
[4,5,6]
])
b=np.tile(a,(3,1))
print(b)
#输出结果
[[1 2 3]
[4 5 6]
[1 2 3]
[4 5 6]
[1 2 3]
[4 5 6]]
9 迭代数组
NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代
import numpy as np
a = np.arange(6).reshape(2,3)
print ('原始数组是：')
print (a)
print ('迭代输出元素：')
for x in np.nditer(a):
print (x, end=", " )
#输出结果为：
原始数组是：
[[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 ('原始数组的转置是：')
b = a.T
print (b)
print ('以 C 风格顺序排序：')
c = b.copy(order='C')
print (c)
for x in np.nditer(c):
print (x, end=", " )
print ('以 F 风格顺序排序：')
c = b.copy(order='F')
print (c)
for x in np.nditer(c):
print (x, end=", " )
#输出结果为：
原始数组是：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
原始数组的转置是：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
以 C 风格顺序排序：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55,
以 F 风格顺序排序：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,
可以通过显式设置，来强制 nditer 对象使用某种顺序：
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('原始数组是：')
print (a)
print ('以 C 风格顺序排序：')
for x in np.nditer(a, order = 'C'):
print (x, end=", " )
print ('以 F 风格顺序排序：')
for x in np.nditer(a, order = 'F'):
print (x, end=", " )
#输出结果为：
原始数组是：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
以 C 风格顺序排序：
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,
以 F 风格顺序排序：
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55,
修改数组中元素的值
nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 readwrite 或者 writeonly 的模式。
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('原始数组是：')
print (a)
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x
print ('修改后的数组是：')
print (a)
#输出结果为：
原始数组是：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
修改后的数组是：
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
使用外部循环
nditer 类的构造器拥有 flags 参数，它可以接受下列值：
| 参数 | 描述 |
|---|---|
| c_index | 可以跟踪 C 顺序的索引 |
| f_index | 可以跟踪 Fortran 顺序的索引 |
| multi_index | 每次迭代可以跟踪一种索引类型 |
| external_loop | 给出的值是具有多个值的一维数组，而不是零维数组 |
在下面的实例中，迭代器遍历对应于每列，并组合为一维数组。
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('原始数组是：')
print (a)
print ('修改后的数组是：')
for x in np.nditer(a, flags = ['external_loop'], order = 'F'):
print (x, end=", " )
#输出结果为：
原始数组是：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
修改后的数组是：
[ 0 20 40], [ 5 25 45], [10 30 50], [15 35 55],
广播迭代
如果两个数组是可广播的，nditer 组合对象能够同时迭代它们。 假设数组 a 的维度为 3X4，数组 b 的维度为 1X4 ，则使用以下迭代器（数组 b 被广播到 a 的大小）。
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('第一个数组为：')
print (a)
print ('第二个数组为：')
b = np.array([1, 2, 3, 4], dtype = int)
print (b)
print ('修改后的数组为：')
for x,y in np.nditer([a,b]):
print ("%d:%d" % (x,y), end=", " )
#输出结果为：
第一个数组为：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
第二个数组为：
[1 2 3 4]
修改后的数组为：
0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4,
146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
