前言

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

• 一个强大的N维数组对象 ndarray
• 广播功能函数
• 整合 C/C++/Fortran 代码的工具
• 线性代数、傅里叶变换、随机数生成等功能

  numpy安装

  # 使用conda进行安装
  $ conda install numpy

  # 使用pip进行安装
  $ pip install numpy

  验证是否安装成功：

  $ python
  >>> import numpy as np
  >>> eye(4)
  array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

  Ndarray对象

  创建ndarray对象，使用numpy的array函数即可

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

创建一个一维数组

a = np.array([1, 2, 3, 4, 5, 6, 7], dtype=np.float32)
print(a)

运行结果：

[1. 2. 3. 4. 5. 6. 7.]

创建一个2维数组

a = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int8)
print(a)

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

numpy数据类型

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

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

NumPy数组属性

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

a = np.array([[1, 2, 3, 4, 5], [0, 1, 2, 3, 4]])
print('a.ndim:', a.ndim)
print('a.shape:', a.shape)
print('a.size:', a.size)
print('a.dtype:', a.dtype)
print('a.itemsize:', a.itemsize)

运行结果：

a.ndim: 2 a.shape: (2, 5) a.size: 10 a.dtype: int32 a.itemsize: 4

创建数组

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

numpy.empty()

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

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

a = np.empty((2, 3, 4), dtype=np.int8)
print(a)

运行结果：

[[[1 1 1 0] [0 0 0 0] [0 0 1 1]]

[[1 1 1 1] [1 1 1 1] [1 1 1 1]]]

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

numpy.zeros()

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

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

a = np.zeros((2, 3, 4), dtype=np.int8)
print(a)

运行结果：

[[[0 0 0 0] [0 0 0 0] [0 0 0 0]]

[[0 0 0 0] [0 0 0 0] [0 0 0 0]]]

numpy.ones()

a = np.ones((2, 3, 4), dtype=np.float32)
print(a)

运行结果：

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

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

运行结果：

[1 2 3]

Numpy从数值范围创建数组

numpy.arange()

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

x = np.arange(5)  
print(x)

[0 1 2 3 4]

NumPy切片

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

[2 3 4 5 6 7 8 9]

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

[2 3 4]

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。

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

Numpy高级索引

整数数组索引

x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print (y)

运行结果：

[1 4 5]

布尔索引

我们可以通过一个布尔数组来索引目标数组。
布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
以下实例获取大于 5 的元素：

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。

a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print (a[~np.isnan(a)])

[ 1. 2. 3. 4. 5.]

以下实例演示如何从数组中过滤掉非复数元素。

a = np.array([1,  2+6j,  5,  3.5+5j])  
print (a[np.iscomplex(a)])

[2.0+6.j 3.5+5.j]

花式索引

略…

NumPy广播 BroadCast

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

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 将自动触发广播机制。如：

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

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

4x3 的二维数组与长为 3 的一维数组相加，等效于把数组 b 在二维上重复 4 次再运算：

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

广播的规则:

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
• 输出数组的形状是输入数组形状的各个维度上的最大值。
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

• 数组拥有相同形状。
• 当前维度的值相等。
• 当前维度的值有一个是 1。
• 若条件不满足，抛出 “ValueError: frames are not aligned” 异常。

  NumPy数组操作

  修改数组形状

  | 函数 | 描述 | | —- | —- | | reshape | 不改变数据的条件下修改形状 | | flat | 数组元素迭代器 | | flatten | 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 | | ravel | 返回展开数组 |

numpy.reshape()

a = np.arange(8)
print ('原始数组：')
print (a)
print ('\n')

b = a.reshape(4,2)
print ('修改后的数组：')
print (b)

运行结果:

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

修改后的数组： [[0 1] [2 3] [4 5] [6 7]]

numpy.ndarray.flat

a = np.arange(9).reshape(3,3) 
print ('原始数组：')
for row in a:
    print (row)

#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
    print (element)

运行结果：

原始数组： [0 1 2] [3 4 5] [6 7 8] 迭代后的数组： 0 1 2 3 4 5 6 7 8

numpy.ndarray.flatten()

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

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

输出结果如下：

原数组： [[0 1 2 3] [4 5 6 7]]

展开的数组： [0 1 2 3 4 5 6 7]

以 F 风格顺序展开的数组： [0 4 1 5 2 6 3 7]

numpy.ravel()

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

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

运行结果：

原数组： [[0 1 2 3] [4 5 6 7]]

调用 ravel 函数之后： [0 1 2 3 4 5 6 7]

以 F 风格顺序调用 ravel 函数之后： [0 4 1 5 2 6 3 7]

翻转数组

numpy.transpose

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

numpy.transpose(arr, axes)

a = np.arange(12).reshape(3,4)

print ('原数组：')
print (a )
print ('\n')

print ('对换数组：')
print (np.transpose(a))

运行结果：

原数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]

对换数组： [[ 0 4 8] [ 1 5 9] [ 2 6 10] [ 3 7 11]]

numpy.ndarray.T 类似 numpy.transpose：

a = np.arange(12).reshape(3,4)

print ('原数组：')
print (a)
print ('\n')

print ('转置数组：')
print (a.T)

运行结果：

原数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]

转置数组： [[ 0 4 8] [ 1 5 9] [ 2 6 10] [ 3 7 11]]

numpy.rollaxis

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

numpy.rollaxis(arr, axis, start)

…下面都是比较复杂的Api了， 暂时可能用不到。。。以后用到了再学。。。
。。。
。。。
。。。