写在前面：为啥要用Numpy？

四个字概括Numpy的好处：又省又快

为什么省？
python的整型啊，列表啊，数组啊，就很不纯粹。

例如整型，它其实是一个指针，指向包含这个对象所有信息的某个内存位置，python整型结构体内还包含引用计数、变量类型编码、数据成员大小等其他信息，负担很大。

再比如说列表，python列表是动态的，可以混合存储多种数据类型，这种灵活便捷的特性导致需要额外的信息。

而Numpy的数组结构在内存中连续存储，且每个数组数据类型必须统一，减少了额外信息的负担。

为什么快？
Numpy的数组在内存中连续存储，这样加快了遍历速度。且这种存储方式使得Numpy可以使用现代CPU的矢量化指令计算，加载寄存器中的多个连续浮点数。此外Numpy的矩阵运算可以采用多线程的方式，大大提升计算效率。

创建数组

要使用numpy库，首先import numpy as np

常用方法总结

np.array()	#从python列表创建数组
np.zeros()	#创建值全为0的数组
np.ones()	#创建值全为1的数组
np.full()	#创建值全为指定值的数组
np.arange()		#创建线性序列数组
np.linspace()	#创建等差数列数组
np.random.random()	#创建值服从0-1均匀分布的随机数组
np.random.normal()	#创建值服从正态分布的随机数组
np.random.randint()	#给定区间内创建值为整形的随机数组
np.eye()	#创建单位矩阵
np.empty()	#创建未初始化的整型数组

具体实例

np.array()

#从列表创建整形数组
a=np.array([0,1,2,3,4,5])	
#数组中类型必须统一，否则将被强制向上转换(与第一个元素同类型)
b=np.array([3.14,6,4,8])	
#创建指定数据类型数组
c=np.array([0,1,2,3,4,5],dtype='float32')
#创建多维数组
d=np.array([range(i,i+3) for i in [2,4,6]])

print(a)
print(b)
print(c)
print(d)

'''
运行结果
[0 1 2 3 4 5]
[3.14 6.   4.   8.  ]
[0. 1. 2. 3. 4. 5.]
[[2 3 4]
 [4 5 6]
 [6 7 8]]
'''

创建等值数组

#创建一个长度为10的数组，数组值都是0
e=np.zeros(10,dtype=int)
#创建一个3*5的浮点型数组，数组值都是1
f=np.ones((3,5),dtype=float)
#创建一个3*5的浮点型数组，数组值都是3.14
g=np.full((3,5),3.14)

print(e)
print(f)
print(g)

'''
运行结果
[0 0 0 0 0 0 0 0 0 0]
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
[[3.14 3.14 3.14 3.14 3.14]
 [3.14 3.14 3.14 3.14 3.14]
 [3.14 3.14 3.14 3.14 3.14]]
'''

创建有序数组

#创建一个从0开始，到20结束，步长为2的线性序列数组(类似python内置的range函数)
h=np.arange(0,20,2)
#创建有5个元素，且这5个元素在0-1范围内均匀分布的等差数组
i=np.linspace(0,1,5)

print(h)
print(i)

'''
运行结果
[ 0  2  4  6  8 10 12 14 16 18]
[0.   0.25 0.5  0.75 1.  ]
'''

创建随机数组

#创建一个3*3、值均匀分布在0-1区间内的随机数组
j=np.random.random((3,3))
#创建一个3*3、值服从标准正态分布(均值为0，标准差为1)的随机数组
k=np.random.normal(0,1,(3,3))
#创建一个3*3、值为[0,10)区间内的整型的随机数组
l=np.random.randint(0,10,(3,3))

print(j)
print(k)
print(l)

'''
运行结果
[[0.14517821 0.01417107 0.68718684]
 [0.80003327 0.73692073 0.4318788 ]
 [0.94794622 0.00841595 0.13685366]]
[[-0.2629605  -0.16238014  0.64910155]
 [-2.25631845  0.77104243 -0.85479106]
 [ 0.7664535  -1.37776241  1.15815201]]
[[6 5 0]
 [5 5 0]
 [6 1 6]]
'''

创建单位矩阵、未初始化数组

#创建一个3*3的单位矩阵
m=np.eye(3)
#创建一个由三个整型数组成的、值为内存中的任意值的未初始化数组
n=np.empty(3)

print(m)
print(n)

'''
运行结果
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
[7.81250000e-03 3.20000076e+01 2.04800049e+03]
'''

创建结构化数组

#复合类型结构化数组
name=['Zhangfei','Guanyu','Zhaoyun','Huangzhong','Dianwei']
Chinese=[66     ,95      ,93       ,90          ,80]
English=[65     ,85      ,92       ,88          ,90]
Math=   [30     ,98      ,96       ,77          ,90]
#复合类型是字典
datatype=np.dtype({
	'names':('name','chinese','english','math'),
	'formats':('U10','i4','i4','i4')	#U10：长度不超过10的unicode字符串，i4:4字节整型
})
#复合类型是元组列表
datatype=np.dtype([('name','U10'),('chinese','i4'),
				   ('english','i4'),('math','i4')])

data=np.zeros(5,dtype=datatype)
data['name']=name
data['chinese']=Chinese
data['english']=English
data['math']=Math
print(data)
#获取所有名字
print(data['name'])
#获取第一行
print(data[0])
#获取最后一行名字
print(data[-1]['name'])
#筛选数学小于60的人的名字
print(data[data['math']<60]['name'])

#记录数组,域可以像属性一样获取，但会加大时间开销
data_rec=data.view(np.recarray)
print(data_rec.name)

'''
运行结果
[('Zhangfei', 66, 65, 30) ('Guanyu', 95, 85, 98) ('Zhaoyun', 93, 92, 96)
 ('Huangzhong', 90, 88, 77) ('Dianwei', 80, 90, 90)]
['Zhangfei' 'Guanyu' 'Zhaoyun' 'Huangzhong' 'Dianwei']
('Zhangfei', 66, 65, 30)
Dianwei
['Zhangfei']
['Zhangfei' 'Guanyu' 'Zhaoyun' 'Huangzhong' 'Dianwei']
'''