0. NumPy的安装

• 使用Anaconda

访问 https://www.anaconda.com/distribution/ ，根据电脑的系统下载对应的软件，安装完成在软件中选择JupyterLab即可使用。

• 使用pip命令（保证您的Python环境已经配置完成）

在CMD中输入python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose等待安装完成即可。

附：安装验证

输入下列代码能得到结果即代表着安装成功:

from numpy import *
eye(4)

输出：

array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

1. NumPy库简介

NumPy是一个科学计算基础库其中提供了许多向量和矩阵操作，能让用户轻松完成最优化、线性代数、积分、插值、特殊函数、傅里叶变换、信号处理和图像处理、常微分方程求解以及其他科学与工程中常用的计算，不仅方便易用而且效率更高。

2. NumPy

NumPy数组的维数称为秩（rank），秩就是轴的数量，一位数组的秩为1，二维数组的秩为2，依次类推。在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

2.1 Ndarray

Ndarray（N维数组）对象是NumPy最重要的一个特点，它是一系列同类型数据的集合，以0下标为开始进行集合中元素的索引。ndarray对象是用于存放同类型元素的多维数组，其中的每个元素在内存中都有相同存储大小的区域，该对象具有矢量算术能力和复杂的广播能力。可以执行一些科学运算，ndarray对象中定义了一些重要属性，如下表所示：

示例：

import numpy as np
data = np.arange(12).reshape(3, 4)
print("data=", data)
print("type(data)=", type(data))
print("data.ndim=", data.ndim)
print("data.shape=", data.shape)
print("data.size=", data.size)
print("data.dtype=", data.dtype)

输出：

data= [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
type(data)= <class 'numpy.ndarray'>
data.ndim= 2
data.shape= (3, 4
data.size= 12
data.dtype= int32

解析：

在代码示例中，第一行将numpy库导入并将其取名为np，第二行初始化一个三行四列的递增数组data,第三行输出data,第四行输出data的类型，第五行输出了数组的维度个数，第六行输出了数组的维度，第七行输出了数组中元素的总个数，第八行输出了元素的类型。

2.1.1 常用属性

• ndarray.shape属性

ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。ndarray.shape 也可以用于调整数组大小。

代码：

import numpy as np
data = np.arange(12)
print("更改前的数组:", data)
data.shape = (3, 4)
print("更改后的数组:", data)

输出：

更改前的数组: [ 0  1  2  3  4  5  6  7  8 
 9 10 11]
更改后的数组: [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

• reshape()函数

reshape()函数可用来调整数组大小，例如：

import numpy as np
data = np.arange(12)
print("更改前的数组:", data)
data.shape = (3, 4)
print("更改后的数组:", data)
print("reshape后数值:", data.reshape(2,6))

输出：

更改前的数组: [ 0  1  2  3  4  5  6  7  8 
 9 10 11]
更改后的数组: [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
reshape后数值: [[ 0  1  2  3  4  5]       
 [ 6  7  8  9 10 11]]

• ndarray.flags属性

ndarray.flags 返回 ndarray 对象的内存信息，包含以下属性：

代码：

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
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

2.2 创建NumPy数组

2.2.1 使用array()函数创建数组

语法：

array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0, /)

示例：

import numpy as np
data = np.array([1, 2, 3])
data2 = np.array((1, 2, 3))
data3 = np.array(((1, 2, 3), (4, 5, 6)))
data4 = np.array([1, 2, 3, 4, 5], complex, ndmin=2)
print("data=", data)
print("data2=", data2)
print("data3=", data3)
print("data4=", data4)

输出：

data= [1 2 3]
data2= [1 2 3]
data3= [[1 2 3]
 [4 5 6]]
data4= [[1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]]

解析：

可以通过array()函数由列表、元组转化，由列表/元组转化为多维数组需要子元素为列表/元组的列表/元组，即:

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

都是可以的。

2.2.2 numpy创建数组

• empty()函数

创建一个只分配内存空间的数组，其中的元素将随机填充。

语法：

empty(shape, dtype=float, order='C', /)

代码：

import numpy as np
data = np.empty((3, 5))
print(data)

输出：

[[6.23042070e-307 4.67296746e-307 1.69121096e-306 2.31424250e-306
  1.89146896e-307]
 [7.56571288e-307 3.11525958e-307 1.24610723e-306 1.37962320e-306       
  1.29060871e-306]
 [2.22518251e-306 1.33511969e-306 1.78022342e-306 1.05700345e-307       
  2.76676762e-322]]

• zeros()和ones()函数

zeros()将创建一个用指定形状用0填充的数组。默认的dtype是float64。

ones()将创建一个用指定形状用1填充的数组。默认的dtype是float64。

语法：

zeros(shape, dtype=float, order='C', /)
ones(shape, dtype=None, order='C')

代码：

import numpy as np
data_0 = np.zeros((2, 3))
data_1 = np.ones((3, 2))
print("data_0=", data_0)
print("data_1=", data_1)

输出：

data_0= [[0. 0. 0.]
 [0. 0. 0.]]
data_1= [[1. 1.]
 [1. 1.]
 [1. 1.]]

2.2.3 从数值范围创建数组

• arange()函数

arrange()函数将创建具有有规律递增值的数组。

语法：

arange(start=None, stop, step=None,dtype=None, /)

代码：

import numpy as np
data = np.arange(10)
data1 = np.arange(1, 10)
data2 = np.arange(1, 10, 2)
data3 = np.arange(10, 1, -2)
dataf = np.arange(1, 10, 2, float)
print("data=", data)
print("data1=", data1)
print("data2=", data2)
print("data3=", data2)
print("dataf=", dataf)

输出：

data= [0 1 2 3 4 5 6 7 8 9]
data1= [1 2 3 4 5 6 7 8 9]
data2= [1 3 5 7 9]
data3= [1 3 5 7 9]
dataf= [1. 3. 5. 7. 9.]

• linspace()函数

linspace() 将创建具有指定数量元素的数组，并在指定的开始值和结束值之间平均间隔。该数组为指定起始值的等差数列。

语法：

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

代码：

import numpy as np
data = np.linspace(0,6,3,endpoint=False)
data_2 = np.linspace(0,6,3)
print(data)
print(data_2)

输出：

[0. 2. 4.]
[0. 3. 6.]

• logspace()函数

logspace()用于创建一个等比数列。

语法：

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

$$ 数组为:[{base}^{start},……,{base}^{stop}],其中endpoint=True $$

代码：

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

输出：

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

2.2.4 从已有的数组创建数组

• asarray()函数

语法：

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

代码：

import numpy as np
x = [1, 2, 3]
y = (4, 5, 6)
z = [(7, 8), (9, 10, 11)]
# 从列表创建数组
a = np.asarray(x)
# 从元组创建数组
b = np.asarray(y)
# 从元组列表创建数组
c = np.asarray(z)
print(a, b, c)

输出：

[1 2 3] [4 5 6] [(7, 8) (9, 10, 11)]

当然，asarray也可以设置dtype属性，例如：

import numpy as np 

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

输出为：

[ 1.  2.  3.]

• frombuffer()函数

numpy.frombuffer 用于实现动态数组。numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

语法：

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

注意：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。

代码：

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

2.3 数据类型

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

2.3.1 查看数据类型

通过ndarray.dtype可以创建一个表示数据类型的对象，如果想要获取数据类型名称，需要访问name属性进行获取，例如：

import numpy as np
data = np.array([[1, 2, 3], [4, 5, 6]])
print(data.dtype.name)

本段代码在64位Windows系统将输出int32，在64位Linux或MacOS中将输出int64

2.3.2 创建数据类型

可以通过如下语法构造dtype对象

numpy.dtype(object, align, copy)

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

每一个NumPy内置的数据类型都有一个特征码，它能唯一标识一种数据类型，具体如表所示：

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

import numpy as np
# 创建car类型
car = np.dtype([('name', 'a3'), ('age', 'i1'), ('speed', 'f4')])
# 创建dtype为car类型的数组
a = np.array([('xz', 1, 20), ('ln', 2, 10)], dtype=car)
print(a)

输出为：

[(b'xz', 1, 20.) (b'ln', 2, 10.)]

2.3.3 转换数据类型

• astype()函数

该函数可以对ndarray对象的数据类型进行转换。

代码：

import numpy as np
data = np.zeros((2, 3))
print("修改前的类型:", data.dtype)
int_data = data.astype(np.int64)
print("修改后的类型", int_data.dtype)

输出：

修改前的类型: float64
修改后的类型 int64

2.4 切片和索引

2.4.1 一维切片

在Python中接触过使用list函数的切片操作，ndarray对象内容可以同样通过索引或切片操作来访问和修改，基于0 - n的下标进行索引，使用内置的slice函数，设置start，stop，step参数，从原数组中切割出一个新数组，其中slice语法为：

slice(start: Any, stop: Any, step: Any=...)
slice(stop)
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],也可使用负数进行负索引

import numpy as np
a = np.arange(10)
print(a[2], " ", a[-2])

输出为：2 8

• 如果使用[2:]则输出从该索引(包括该元素)之后的所有项

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

输出为：[2 3 4 5 6 7 8 9]

• 如果使用[:7]则输出从该索引(不包括该元素)之前的所有项

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

输出为：[0 1 2 3 4 5 6]

• 如果使用[2:7]那么则提取两个索引(不包括停止索引)之间的项

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

输出为：[2 3 4 5 6]

• 同样可以使用负值对数组进行反转[::-1]

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

输出为：[9 8 7 6 5 4 3 2 1 0]

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

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

更多例子：

import numpy as np
a = np.arange(10)
print(a[1:9:2])  # 输出在索引为1和9之间(不包括9)步长为2的元素
print(a[9:1:-2])  # 反向输出在索引为9和1之间(不包括1)步长为2的元素

输出为：

[1 3 5 7]
[9 7 5 3]

2.4.2 多维切片

冒号分割函数在多维数组的处理上也很方便，在多维数组切片[x,y]，x代表行号，y代表列号，例如下图中为二维数组中对应的冒号索引。

例如下列代码：

import numpy as np
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(a[2,1])

输出为10，即为第2行第1列的元素。在多维数组的每一维同样可以使用:索引，在讲解多维数组下的:索引之前先引入一下省略号切片：

如图所示，如果需要输出第2行元素只需使用：

import numpy as np
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(a[2, ...])
print(a[2])    # 当省略号代表列时可省略

而输出第2列元素可以使用：

import numpy as np
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(a[..., 2])

多维数组下的:索引

创建一个4×4的二维数组，一些区域访问的例子如下图所示：

代码：

import numpy as np
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(a[1:3, 0])
print(a[2:, 1])
print(a[:3])
print(a[..., :3])
print(a[0::2, 2])
print(a[3:0:-2, 2])
print(a[0:2, 1:3])
print(a[::2, 0:])
print(a[::-2, 0:])

输出：

[5 9]
[10 14]
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
[[ 1  2  3]
 [ 5  6  7]
 [ 9 10 11]
 [13 14 15]]
[ 3 11]
[15  7]
[[2 3]
 [6 7]]
[[ 1  2  3  4]
 [ 9 10 11 12]]
[[13 14 15 16]
 [ 5  6  7  8]]

如果我们需要填充一个8×8的棋盘，黑的为0，白的为1，可以使用:索引迅速填充：

import numpy as np
chess = np.zeros((8, 8), int)
chess[::2, 1::2] = 1
chess[1::2, ::2] = 1
print(chess)

2.4.3 花式索引与布尔索引

花式索引的基本形式如下图所示：

import numpy as np
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(a[[0, 3]])
print(a[..., [0, 3]])
print(a[[0, 3], [1, 3]])
print(a[[0, 1, 2, 0, 3], [0, 2, 3, 1, 2]])

输出为：

[[ 1  2  3  4]
 [13 14 15 16]]
[[ 1  4]
 [ 5  8]
 [ 9 12]
 [13 16]]
[ 2 16]
[ 1  7 12  2 15]

当花式索引使用一个数组做索引，即a[[x,y]]或a[..., [x,y]]形式时，输出第x,y行/列的元素，而当使用两个数组做索引，即a[[x,y],[m,n]]形式时，输出第x行m列和第y行第n列的元素。

np.ix_

代码：

import numpy as np

x = np.arange(32).reshape((8, 4))
print(x[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])])
print(x[[1, 5, 7, 2], [0, 3, 1, 2]])

输出：

[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]
[ 4 23 29 10]

可以看出np.ix_方法第一个参数指定的是行，第二个参数指定的该行选取列的顺序。

布尔索引指的是将一个布尔数组作为数组索引，返回的数据是布尔数组中True对应位置的值，比如一个简单的例子：

考试结束五个同学的成绩如下表：

使用student存储姓名，使用student_score存储学生成绩，使用布尔索引输出姓名为zyh的成绩

代码：

import numpy as np
student = np.array(['zz', 'yxy', 'wyf', 'wcc', 'zyh'])
student_score = np.array([[98, 64, 87], [100, 92, 76], [67, 99, 90],
                          [80, 100, 99], [79, 95, 66]])

print(student == 'zyh')
# 将布尔数组作为索引应用于存储成绩的数组，返回的数据是True值对应的行
print(student_score[student == 'zyh'])
# 布尔型数组与切片混合使用
print(student_score[student == 'zyh', 1:])

输出：

[False False False False  True]
[[79 95 66]]
[[95 66]]

在使用布尔型索引获取值得时候，除了可以使用"=="运算符还可以使用"!="、"-"来进行否定、">"和"<"来判断数值大小以及"&"和"|"等符号来组合多个布尔条件。