Numpy简述
Numpy是Python中科学计算的基础包，它是一个Python库，提供多维数组对象，各种派生对象（如：掩码数组和矩阵），同时提供对数组/数据的各种操作。
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 位浮点数（实数部分和虚数部分） |
注意：每个内建类型都有一个唯一定义它的字符代码，如下：
| 字符 | 对应类型 |
|---|---|
| b | 布尔类型 |
| i | (有符号) 整型 |
| u | 无符号整型 integer |
| f | 浮点型 |
| c | 复数浮点型 |
| m | timedelta（时间间隔） |
| M | datetime（日期时间） |
| O | (Python) 对象 |
| S, a | (byte-)字符串 |
| U | Unicode |
| V | 原始数据 (void) |
注：字节顺序是通过对数据类型预先设定"<“或”>“来决定的。”<“意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。”>"意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。
数组的属性
1.维度（ndim）
2.形状（shape）：可以理解成数组各个维度的长度
3.长度（size）：数组存储元素的总个数
4.数据类型（dtype）：数组的数据类型（数组要求数据必须同一类型）
5.itemsize：每个元素的字节长度
6.nbytes：nbytes=itemsize*size（可以理解为整个数组占多大内存）
import numpy as np
a1 = np.random.randint(100,size=10) #创建一个一维数组
a2 = np.random.randint(100,size=(4,6)) #创建一个4行6列的数组
a3 = np.random.randint(100,size=(2,5,6)) #创建一个三维数组，维度分别是2，5，6
for a in [a1,a2,a3]:
print("dtype={},ndim={},shape={},size={},itemsize={},nbytes={}".format(a.dtype,a.ndim,a.shape,a.size,a.itemset,a.nbytes))
运行结果：
dtype=int32,ndim=1,shape=(10,),size=10,itemsize=4,nbytes=40
dtype=int32,ndim=2,shape=(4, 6),size=24,itemsize=4,nbytes=96
dtype=int32,ndim=3,shape=(2, 5, 6),size=60,itemsize=4,nbytes=240
输出结果可以反映数组的信息对照上面的数组的属性很容易就理解了。
特殊数组的创建
import numpy as np
a = np.empty(3)
print("Empty array:\n ",a)
b = np.zeros([2,3]) #创建多位数组需要将维度填写在“[]”内部
print("Zeros array:\n",b)
c = np.ones([2,3,4])
print("Ones array:\n",c)
运行结果：
Empty array:
[2.88995698e+204 2.00416324e-312 3.51086921e+151]
Zeros array:
[[0. 0. 0.]
[0. 0. 0.]]
Ones array:
[[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
数组的索引和切片
import numpy as np
a = np.random.randint(100,size=10) #创建一个随机整形数组，大小是10.
print(a)
#numpy数组的索引和list类似
print("a[1]=",a[1])
print("a[-1]=",a[-1])
运行结果：
[68 90 46 9 10 71 47 19 54 57]
a[1]= 90
a[-1]= 57
注意：数组从头开始第一个的下角标是“0”，而从末尾开始第一个的下角标是“-1”
import numpy as np
a = np.random.randint(100,size=(3,5))
print("a=",a)
print("a[1] = ",a[1]) #输出下角标位1的行
print("a[1:]=",a[1,:]) #这里是切片，选出下角标为1的行从第一个元素到最后一个，和list一样
print("a[-2]=",a[-2]) #输出倒数第二行数组
print("a[:2]=",a[:,2]) #输出下角标位2的一列元素
print("a[2][2]=",a[2][2]) #输出角标是（2，2）的元素
print("a[-2][-2]=",a[-2][-2]) #输出角标是倒数第二行倒数第二列的元素
运行结果：
a= [[66 3 17 7 48]
[30 66 22 62 18]
[65 9 14 55 84]]
a[1] = [30 66 22 62 18]
a[1:]= [30 66 22 62 18]
a[-2]= [30 66 22 62 18]
a[:2]= [17 22 14]
a[2][2]= 14
a[-2][-2]= 62
注：切片的基本用法—x[开始:结束:步长]，三个参数决定切片的结果，有些可以省略，如步长如果是“1”便可以不写
import numpy as np
a = np.arange(1,10)
print("a = ",a)
print("a[3：7]=",a[3,7]) #取得下角标是（3，7）的元素
print("a[1::2]=",a[1::2]) #取得从下角标为1的元素开始到最后，步长为2（步长就是间隔几个取一次）
print("a[:5]=",a[:5]) #取得前五个元素
print("a[5:]=",a[5:]) #取得从第五个到最后的元素
print("a[:-6:-1]=",a[:-6:-1]) #从最后一个开始取到倒数第六个步长是1
运行结果：
a = [1 2 3 4 5 6 7 8 9]
a[3,7]= [4 5 6 7]
a[1::2]= [2 4 6 8]
a[:5]= [1 2 3 4 5]
a[5:]= [6 7 8 9]
a[:-6:-1]= [9 8 7 6 5]
import numpy as np
a = np.random.randint(10,size=(5,5))
print("a = ","\n",a)
print("a[1:4,1:4]=",a[1:4,1:4]) #截取多位数组的一段，
print("a[1:4:-1,1:4:-1]=",a[1:5:-1,1:5:-1]) #setp参数可以是负数但是标识逆序。
print("a[::-1,::-1]=\n",a[::-1,::-1])
运行结果：
a =
[[7 8 0 8 1]
[6 0 0 9 4]
[1 8 5 4 0]
[8 7 7 9 1]
[9 2 9 0 7]]
a[1:4,1:4]= [[0 0 9]
[8 5 4]
[7 7 9]]
a[1:4:-1,1:4:-1]= []
a[::-1,::-1]=
[[7 0 9 2 9]
[1 9 7 7 8]
[0 4 5 8 1]
[4 9 0 0 6]
[1 8 0 8 7]]
import numpy as np
a = np.random.randint(10,size=(3,5))
print("a=\n",a)
print("a[1,:]=",a[1,:]) #取得第二行
print("a[::-1,1]=",a[::-1,1]) #取得倒序第二列
print("a[0]=",a[0]) #空的切片可以省略，例如：a[0，：]
运行结果：
a=
[[8 8 9 8 1]
[8 7 8 3 6]
[8 4 4 4 7]]
a[1,:]= [8 7 8 3 6]
a[::-1,1]= [4 7 8]
a[0]= [8 8 9 8 1]
注意：数组切片和list不同，数组切片的结果是源数据的视图而不是副本。如果又不了解的可以去下面的链接了解一下。
https://www.jianshu.com/p/913a332e4dfc
数组的变形
1.数组的变形可以通过reshape来进行操作，前提是必须前后长度一致
2.也可以通过newaxis关键字来完成（newaxis是一个NoneType的内容，其实就是None）
import numpy as np
a = np.arange(1,10).reshape((3,3))
print("a=\n",a)
print("a.shape=",a.shape) #查看数组维度
运行结果：
a=
[[1 2 3]
[4 5 6]
[7 8 9]]
a.shape= (3, 3)
import numpy as np
a1 = np.arange(10)
print("a1=",a1)
print("a1.shape=",a1.shape)
a2 = a1[np.newaxis,:] #使a2获得一个行向量
print("a2=",a1)
print("a2.shape=",a2.shape)
a3 = a1[:,np.newaxis] #使a3获得一个列向量
print("a3=",a3)
print("a3.shape=",a3.shape)
运行结果：
a1= [0 1 2 3 4 5 6 7 8 9]
a1.shape= (10,)
a2= [0 1 2 3 4 5 6 7 8 9]
a2.shape= (1, 10)
a3= [[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]]
a3.shape= (10, 1)
注意：这里newaxis只是单纯的增加一个维度。
