numpy：是数据结构基础，主要处理python在数据和数值计算过程中处理速度慢的问题。
功能：1、提供了一种新的数据结构, ndarray(数组)
2、丰富的多维操作
3、线性代数方面的运算
官网：http://www.numpy.org/
numpy的数据结构中只能有一种数据类型，通过（dtype=np.类型）定义数据类型。数据类型有bool, int, int8, int16, int32, int64, int128, uint8, uint16, uint32, uint64, uint128, float, float16, float32, float64, complex64/128.
数据维度的Python表示：
| 数据维度 | python表示 | 示例 |
| 一维数据 | 列表和集合类型 | 有序[3.1398, 3.1349, 3.1376] 无序{3.1398, 3.1349, 3.1376} |
| 二维数据 | 列表类型 |
[[3.1398, 3.1349, 3.1376], [3.1498, 3.1449, 3.1476]] |
| 多维数据 | 列表类型 |
一、属性
np.array()生成一个ndarray数组，ndarray在程序中的别名是：array
np.array()输出成[]形式，元素由空格分隔。
1 import numpy as np
2 a = np.array([[0,1,2,3,4],[9,8,7,6,5]])
3 a
4 array([[0, 1, 2, 3, 4],
5 [9, 8, 7, 6, 5]])
6 print(a)
7 [[0 1 2 3 4]
8 [9 8 7 6 5]]
轴（axis）：保存数据的维度 秩（rank）：轴的数量
np.array是numpy中最基础的数据结构, 这个数据结构中的属性有：
| 属性 | 说明 |
| shape | 指明形状 |
| ndim | 维数 |
| dtype | 数据类型 |
| itemsize | np.array中每个元素的大小，以字节为单位 |
| size | numpy的大小 |
输出list和array示例：
1 #encoding = utf-8
2 import numpy as np
3 #encoding = utf-8
4 import numpy as np
5 list1 = [[[1,2,3,4],
6 [4,5,6,7]],
7 [[7,8,9,10],
8 [10,11,12,13]],
9 [[14,15,16,17],
10 [18,19,20,21]]]
11 list2 = np.array([[[1,2,3,4],
12 [4,5,6,7]],
13 [[7,8,9,10],
14 [10,11,12,13]],
15 [[14,15,16,17],
16 [18,19,20,21]]
17 ])
18 print("输出列表：")
19 print(list1)
20 print("输出数列：")
21 print(list2)
22
23 运行结果：
24 输出列表：
25 [[[1, 2, 3, 4], [4, 5, 6, 7]], [[7, 8, 9, 10], [10, 11, 12, 13]], [[14, 15, 16, 17], [18, 19, 20, 21]]]
26 输出数列：
27 [[[ 1 2 3 4]
28 [ 4 5 6 7]]
29
30 [[ 7 8 9 10]
31 [10 11 12 13]]
32
33 [[14 15 16 17]
34 [18 19 20 21]]]
shape、ndim、dtype、itemsize、size的操作示例：
1 #encoding = utf-8
2 import numpy as np
3
4 def main():
5 list1 = [[1,3,5],[2,4,6]]
6 print(type(list1))
7 np_list1 = np.array(list1)
8 print(type(np_list1))
9 np_list1 = np.array(list1, dtype = np.float)
10 print(np_list1.shape)
11 print(np_list1.ndim)
12 print(np_list1.dtype)
13 print(np_list1.itemsize)
14 print(np_list1.size)
15
16 if __name__ == "__main__":
17 main()
18
19 #输出结果
20 <class 'list'>
21 <class 'numpy.ndarray'>
22 (2, 3)
23 2
24 float64
25 8
26 6
ndarray的元素类型：
| 数据类型 | 说明 |
| bool | 布尔类型，True或False |
| intc | 与C语言中的int类型一致，一般是int32或int64 |
| intp | 用于索引的整数，与C语言中的ssize_t一致，int32或int64 |
| int8 | 字节长度的整数，取值：[-128,127] |
| int16 | 16位长度的整数，取值：[-32768,32767] |
| int32 | 32位长度的整数，取值：[-231,231-1] |
| int64 | 64位长度的整数，取值：[-263,263-1] |
| uint8 | 8位无符号整数，取值：[0,255] |
| uint16 | 16位无符号整数，取值：[0,65535] |
| uint32 | 32位无符号整数，取值：[0,232-1] |
| uint64 | 64位无符号整数，取值：[0,264-1] |
| float16 | 16位半精度浮点数：1位符号位，5位指数，10位尾数 |
| float32 | 32位半精度浮点数：1位符号位，8位指数，23位尾数 |
| float64 | 64位半精度浮点数：1位符号位，11位指数，52位尾数 |
| complex64 | 复数类型，实部和虚部都是32位浮点数 |
| complex128 | 复数类型，实部和虚部都是64位浮点数 |
python语法仅支持整数、浮点数和复数3中类型，而ndarray支持表中那么多元素类型，原因是：
1、科学计算涉及数据较多，对存储和性能都有较高要求。
2、对元素类型精细定义，有助于Numpy合理使用存储空间并优化性能。
3、对元素类型精细定义，有助于程序员对程序规模有合理评估。
二、一些常用的数组
ndarray数组的创建方法：
(1)从python中的列表、元组等类型创建ndarray数组
x = np.array(list/tuple)
x = np.array(list/tuple,dtype=np.float32)
当np.array()不指定dtype时，NumPy将根据数据情况关联一个dtype类型。
(2)使用NumPy中函数创建ndarray数组，如：arange,ones,zeros等
| 数组 | 说明 |
| zeros([m,n]) | 数值初始化，生成m行n列的数组 |
| ones([m,n]) | 元素都置为1，生成m行n列的数组 |
| full(shape,val) | 根据shape生成一个数组，每个元素值都是val |
| random.rand(m,n) | 生成0-1之间服从均匀分布的随机数 |
| random.rand() | 生成0-1之间的1个随机数 |
| random.randint(1,10,3) | 生成3个1-10之间的随机整数，生成整数括号内不能为空 |
| random.randn(m,n) | 生成服从标准正态分布的m行n列的随机数 |
| random.choice([10,20,30]) | 生成10,20,30之间的1个随机数 |
| random.beta(m,n,M) | 生成从m-n之间服从ß分布的M个随机数 |
zeros、ones、random.rand、random.randint、random.randn、random.choice、random.betac操作示例：
1 #encoding = utf-8 2 import numpy as np 3 4 def main(): 5 print("初始化：") 6 print(np.zeros([2,4])) 7 print(np.ones([3,5])) 8 9 print("随机数：") 10 print(np.random.rand(2,4)) 11 print(np.random.rand()) 12 13 print("随机整数：") 14 print(np.random.randint(1,10,3)) 15 16 print("正态分布的随机整数：") 17 print(np.random.randn(2,4)) 18 19 print("一维数组中选择生成随机数：") 20 print(np.random.choice([10,20,30])) 21 22 print("服从beta分布的随机数：") 23 print(np.random.beta(1,10,5)) 24 if __name__ == "__main__": 25 main() 26
#运行结果 27 初始化： 28 [[ 0. 0. 0. 0.] 29 [ 0. 0. 0. 0.]] 30 [[ 1. 1. 1. 1. 1.] 31 [ 1. 1. 1. 1. 1.] 32 [ 1. 1. 1. 1. 1.]] 33 随机数： 34 [[ 0.32200808 0.12104838 0.70322247 0.56456672] 35 [ 0.95257224 0.87371518 0.29743618 0.13854885]] 36 0.37279692507129536 37 随机整数： 38 [7 6 5] 39 正态分布的随机整数： 40 [[ 0.9579207 -0.66080296 -0.12798636 0.20788484] 41 [ 0.19459448 1.06547597 -0.46216803 0.90047683]] 42 一维数组中选择生成随机数： 43 30 44 服从beta分布的随机数： 45 [0.16530894 0.12363116 0.09875519 0.03737488 0.203352]
(3)使用NumPy中其他函数创建ndarray数组
| 函数 | 说明 |
| np.linspace() | 根据起始数据等间距地填充数据，形成数组 |
| np.concatenate() | 根据两个或多个数组合并成一个新的数组 |
1 import numpy as np
2 a = np.linspace(1,10,4)
3 print(a)
4 b = np.linspace(1,10,4,endpoint=False)
5 print(b)
6
7 运行结果：
8 [ 1. 4. 7. 10.]
9 [ 1. 3.25 5.5 7.75]
ndarray数组的维度变换：
| 方法 | 说明 |
| reshape（shape） | 不改变数组元素，返回一个shape形状的数组，原数组不变 |
| resize（shape） | 与reshape功能一致，但修改原数组 |
| swapaxes(ax1,ax2) | 将数组n个维度中的两个维度进行调换 |
| flatten() | 对数组进行降维，返回折叠后的一维数组，原数组不变 |
#reshape操作
1 import numpy as np
2 a = np.ones((2,3,4),dtype=np.int32)
3 print(a)
4 a.reshape(3,8)
5
6 运行结果：
7 [[[1 1 1 1]
8 [1 1 1 1]
9 [1 1 1 1]]
10
11 [[1 1 1 1]
12 [1 1 1 1]
13 [1 1 1 1]]]
14 Out[20]:
15 array([[1, 1, 1, 1, 1, 1, 1, 1],
16 [1, 1, 1, 1, 1, 1, 1, 1],
17 [1, 1, 1, 1, 1, 1, 1, 1]])
#swapaxes操作
1 import numpy as np 2 a = np.array([[1,2,3],[6,5,4]],dtype=np.int32) 3 print(a) 4 a.swapaxes(0,1) 5 6 运行结果： 7 [[1 2 3] 8 [6 5 4]] 9 Out[28]: 10 array([[1, 6], 11 [2, 5], 12 [3, 4]])
ndarray数组的类型变换：
new_a = a.astype(np.float)
astype()方法一定会创建新的数组（原始数据的一个拷贝），即使两个类型一致。
ndarray数组向列表的转换：
a.tolist()
三、numpy中的操作
| 操作 | 说明 | 备注 |
| arange(m,n) | 生成m到n-1的等差数列 | 对numpy进行操作 |
| exp(list) | 对列表进行指数操作 | 对numpy进行操作 |
| exp2(list) | 自然指数的平方 | 对numpy进行操作 |
| sqrt(list) | 开方 | 对numpy进行操作 |
| log(list) | 底数是自然底数 | 对numpy进行操作 |
| sum(axis=0) |
数组是n维，axis可以到n-1。在python中list相加表示追加， numpy中相加会作用到每个作用树上。axis越大深入程度越大。 |
对数组进行操作 |
| max() | 对数组进行操作 | |
| min() | 对数组进行操作 | |
| list1+list2 | ||
| list1-list2 | ||
| list1*list2 | ||
| list**2 | ||
| np.dot(list1,list2) | 对numpy进行操作 | |
| concatenate(list1, list2) | numpy中的array进行追加 | 对numpy进行操作 |
| vstack((list1,list2)) | numpy中的array进行上下追加 | 对numpy进行操作 |
| hstack((list1,list2)) | 对numpy进行操作 | |
| split(list,2) | list分成2份 | 对numpy进行操作 |
| copy(list) | 对数组进行拷贝 | 对numpy进行操作 |
对数组进行求arange、exp、exp2、sin、log操作：
1 #encoding = utf-8
2 import numpy as np
3 #Array operation
4
5 print("arithmetic progression:")
6 print(np.arange(1,11).reshape([2,-1]))#-1表示缺省
7 list1 = np.arange(1,11).reshape([2,-1])
8 print("e^(list1):")
9 print(np.exp(list1))
10 print("(list1)^2:")
11 print(np.exp2(list1))
12 print("sin")
13 print(np.sin(list1))
14 print("log")
15 print(np.log(list1))
16
17 运行结果：
18 arithmetic progression:
19 [[ 1 2 3 4 5]
20 [ 6 7 8 9 10]]
21 e^(list1):
22 [[ 2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01
23 1.48413159e+02]
24 [ 4.03428793e+02 1.09663316e+03 2.98095799e+03 8.10308393e+03
25 2.20264658e+04]]
26 (list1)^2:
27 [[ 2. 4. 8. 16. 32.]
28 [ 64. 128. 256. 512. 1024.]]
29 sin
30 [[ 0.84147098 0.90929743 0.14112001 -0.7568025 -0.95892427]
31 [-0.2794155 0.6569866 0.98935825 0.41211849 -0.54402111]]
32 log
33 [[ 0. 0.69314718 1.09861229 1.38629436 1.60943791]
34 [ 1.79175947 1.94591015 2.07944154 2.19722458 2.30258509]]
sum操作：
1 #encoding = utf-8
2 import numpy as np
3 list2 = np.array([[[1,2,3,4],
4 [4,5,6,7]],
5 [[7,8,9,10],
6 [10,11,12,13]],
7 [[14,15,16,17],
8 [18,19,20,21]]
9 ])
10 print("所有元素相加：")
11 print(list2.sum())#这里不是对numpy进行操作，直接对list进行操作
12 print("第一层相加：")
13 print(list2.sum(axis = 0))
14 print("第二层相加：")
15 print(list2.sum(axis = 1))
16 print("第三层相加：")
17 print(list2.sum(axis = 2))
18
19 运行结果：
20 所有元素相加：
21 252
22 第一层相加：
23 [[22 25 28 31]
24 [32 35 38 41]]
25 第二层相加：
26 [[ 5 7 9 11]
27 [17 19 21 23]
28 [32 34 36 38]]
29 第三层相加：
30 [[10 22]
31 [34 46]
32 [62 78]]
数列相加：
1 #encoding = utf-8
2 import numpy as np
3 list1 = np.array([10,20,30,40])
4 list2 = np.array([4,3,2,1])
5 print("Add:")
6 print(list1+list2)
7
8 运行结果：
9 Add:
10 [14 23 32 41]
数列点乘：
1 #encoding = utf-8
2 import numpy as np
3 list1 = np.array([10,20,30,40])
4 list2 = np.array([4,3,2,1])
5 print("Dot:")
6 print(np.dot(list1.reshape([2,2]), list2.reshape([2,2])))
7
8 运行结果：
9 Dot
10 [[ 80 50]
11 [200 130]]
concatenate、vstack、hstack、split、copy操作：
1 #encoding = utf-8
2 import numpy as np
3 list1 = np.array([10,20,30,40])
4 list2 = np.array([4,3,2,1])
5 print("Concatenate:")
6 print(np.concatenate((list1,list2)))
7 print("Vstack:")
8 print(np.vstack((list1,list2)))
9 print("Hstack:")
10 print(np.hstack((list1,list2)))
11 print("Split:")
12 print(np.split(list1,2))
13 print("Copy:")
14 print(np.copy(list1,2))
15
16 运行结果：
17 Concatenate:
18 [10 20 30 40 4 3 2 1]
19 Vstack:
20 [[10 20 30 40]
21 [ 4 3 2 1]]
22 Hstack:
23 [10 20 30 40 4 3 2 1]
24 Split:
25 [array([10, 20]), array([30, 40])]
26 Copy:
27 [10 20 30 40]
数组的索引和切片：
索引：获取数组中特定位置元素的过程。
切片：获取数组元素子集的过程。
多维数组的索引与切片：
1 import numpy as np
2 a = np.arange(24).reshape(2,3,4)
3 print(a)
4 print("输出索引值1：")
5 print(a[1,2,3])
6 print("输出索引值2：")
7 print(a[-1,-2,-3])
8 print("输出切片1：")
9 print(a[:,1,-3])#选取一个维度用：
10 print("输出切片2：")
11 print(a[:,1:3,:])#每个维度切片方法与一维数组相同
12 print("输出切片3：")
13 print(a[:,:,::2])#每个维度可以使用步长跳跃切片
14
15 运行结果：
16 [[[ 0 1 2 3]
17 [ 4 5 6 7]
18 [ 8 9 10 11]]
19
20 [[12 13 14 15]
21 [16 17 18 19]
22 [20 21 22 23]]]
23 #输出索引值1：
24 23
25 输出索引值2：
26 17
27 输出切片1：
28 [ 5 17]
29 输出切片2：
30 [[[ 4 5 6 7]
31 [ 8 9 10 11]]
32
33 [[16 17 18 19]
34 [20 21 22 23]]]
35 输出切片3：
36 [[[ 0 2]
37 [ 4 6]
38 [ 8 10]]
39
40 [[12 14]
41 [16 18]
42 [20 22]]]
matplotlib:丰富的可视化套件，利用它可以做出折线图、柱状图等各种图表以及复杂的三维图。
pandas:基础数据分析套件，交叉分析，时序分析，假设检验等等。