Numpy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。
下面从数组的创建，随机数的生成，下标索引，维度的查看及改变等方面认识Numpy-数组。
#创建一维数组
import numpy as np #导入 NumPy 库
arr1 = np.array([1, 2, 3, 4]) #创建一维数组
print(' 创建的数组为： ',arr1)
创建的数组为： [1 2 3 4]
# 创建二维数组
arr2 = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
print('创建的数组为：\n',arr2)
创建的数组为：
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]]
#查看数组属性值
print('数组类型为：',arr2.dtype) #查看数组类型
数组类型为： int32
print('数组元素个数为：',arr2.size) #查看数组元素个数
数组元素个数为： 12
print('数组每个元素大小为：',arr2.itemsize) #查看数组每个元素大小
数组每个元素大小为： 4
#重新设置数组的维度
arr2.shape = 4,3 #重新设置维度
print('重新设置维度后的arr2 为：',arr2)
重新设置维度后的arr2 为： [[ 1 2 3]
[ 4 4 5]
[ 6 7 7]
[ 8 9 10]]
#创建数组的方式
print('使用arange函数创建的数组为：\n',np.arange(0,1,0.1))#0~0.9步长为0.1的等差数列
使用arange函数创建的数组为：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
print('使用linspace函数创建的数组为：\n：',np.linspace(0, 1, 10))#0~1内等差数列
使用linspace函数创建的数组为：
： [0. 0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
0.66666667 0.77777778 0.88888889 1. ]
print('使用logspace函数创建的数组为：\n',np.logspace(0, 1, 10))#1~10的一次方内等比数列
使用logspace函数创建的数组为：
[ 1. 1.29154967 1.66810054 2.15443469 2.7825594 3.59381366
4.64158883 5.9948425 7.74263683 10. ]
print('使用zeros函数创建的数组为：\n',np.zeros((2,3)))#零矩阵
使用zeros函数创建的数组为：
[[0. 0. 0.]
[0. 0. 0.]]
print('使用eye函数创建的数组为：\n',np.eye(3))#单位矩阵
使用eye函数创建的数组为：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
print('使用diag函数创建的数组为：\n',np.diag([1,2,3,4]))#对角矩阵
使用diag函数创建的数组为：
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
print('使用ones函数的数组为：\n',np.ones((5,3)))#1矩阵
使用ones函数的数组为：
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
# 转换数据类型
print('转换结果为：',np.float64(10)) #整型转换为浮点型
转换结果为： 10.0
print('转换结果为：',np.int8(10.0)) #浮点型转换为整型
转换结果为： 10
print('转换结果为：',np.bool(10)) #整型转换为布尔型
转换结果为： True
print('转换结果为：',np.bool(0)) #整型转换为布尔型
转换结果为： False
print('转换结果为：',np.float(True)) #布尔型转换为浮点型
转换结果为： 1.0
print('转换结果为：',np.float(False)) #布尔型转换为浮点型
转换结果为： 0.0
# 数据类型
df = np.dtype([("name", np.str_, 40), ("numitems", np.int64),
("price",np.float64)])
print('数据类型为：',df)
数据类型为： [('name', '<U40'), ('numitems', '<i8'), ('price', '<f8')]
print('数据类型为：',df["numitems"])
数据类型为： int64
print('数据类型为：',np.dtype(df["numitems"]))
数据类型为： int64
# 随机数
print('生成的随机数组为：\n',np.random.random(100))#0~1之间的浮点数
生成的随机数组为：
[8.45247163e-01 8.04961236e-01 4.61629100e-01 6.60481056e-01
8.85688953e-01 7.92505304e-01 6.84714900e-01 6.34226585e-01
8.20931780e-01 3.34055152e-01 7.20978384e-01 3.74890972e-01
9.89532417e-01 4.16347259e-01 2.42102254e-01 6.61382437e-01
4.81353414e-01 9.02105584e-01 4.02486538e-01 2.65695021e-01
1.47966508e-01 1.14844259e-01 4.84830607e-01 6.18340708e-01
7.76143270e-01 4.82649768e-01 9.28718489e-01 4.14964185e-01
4.68781154e-01 1.81361248e-01 2.76627027e-01 6.39671817e-01
6.62330659e-01 8.11416506e-01 7.77777655e-01 3.22008857e-01
4.89123991e-01 9.29301696e-01 8.06684663e-01 9.82265016e-01
9.13282612e-01 6.49882735e-01 2.02874844e-01 3.05527821e-01
4.24297211e-01 4.16389231e-01 7.04391535e-01 4.99023359e-01
5.88470538e-01 7.38298384e-01 3.68054772e-01 1.59033896e-01
5.82120938e-01 3.71144145e-01 1.93509476e-01 6.06574724e-01
6.11538706e-02 5.78425437e-01 7.34466790e-01 1.21817500e-01
8.59708037e-01 4.00729070e-01 4.44967775e-01 7.27739695e-01
2.61229858e-01 1.70732866e-01 5.96511175e-01 6.75143973e-01
5.41266836e-01 1.83114421e-01 7.58738714e-04 4.30872768e-01
5.20699554e-01 4.63038120e-01 5.25177320e-01 7.06495083e-01
4.66429035e-01 6.38014308e-01 8.14504474e-02 2.70856520e-01
9.92215242e-01 7.13024171e-01 4.94373814e-01 3.02776512e-01
5.63768564e-01 5.89210265e-01 5.73322187e-01 4.24810060e-01
3.66895265e-01 1.47066063e-01 9.51866724e-01 1.75349586e-01
5.68228734e-01 9.23077343e-02 5.74306533e-01 1.15063710e-01
1.27975927e-01 3.45100855e-01 3.49098592e-01 6.60094569e-01]
print('生成的随机数组为：\n',np.random.rand(10,5))#均匀分布
生成的随机数组为：
[[0.25922467 0.76808373 0.63684366 0.51578544 0.53421494]
[0.72365342 0.48093336 0.83422115 0.88113483 0.17132812]
[0.23065314 0.94135655 0.05371515 0.44028687 0.50151535]
[0.76408248 0.27500197 0.14867752 0.26470363 0.74286716]
[0.33755793 0.95879839 0.15080796 0.53588816 0.78339816]
[0.90092235 0.22243242 0.07556453 0.37230141 0.37591385]
[0.08799716 0.08463172 0.18019147 0.63993616 0.45510651]
[0.76824 0.11750074 0.53298314 0.35589531 0.59611092]
[0.88556225 0.5523454 0.97087332 0.14286531 0.77582827]
[0.11253834 0.87919561 0.21009431 0.08901257 0.35540301]]
print('生成的随机数组为：\n',np.random.randn(10,5))#标准正态分布
生成的随机数组为：
[[ 0.53907684 0.09398254 0.08682753 -0.20524631 0.6739524 ]
[ 0.01369997 -0.51383784 -0.10402955 -0.74558861 -0.9431707 ]
[ 1.54475275 -0.58967622 -0.17420901 0.06108461 0.28348128]
[ 0.20715056 -2.31514807 -0.86914422 -0.10865683 -1.03440973]
[-0.46250783 1.2075892 0.08250644 -1.08742328 -0.78728038]
[-1.30812596 1.35982432 1.32917884 1.15947257 0.76195138]
[ 0.80697121 0.66593556 -0.77120651 0.01326571 0.03444282]
[ 0.59012534 -0.09921907 0.43749378 -0.40498069 0.87905421]
[ 0.37076441 -0.3669176 -1.81459462 2.52145125 -1.14426121]
[-0.69042699 0.25140031 1.06545396 0.25672359 0.08348101]]
print('生成的随机数组为：\n',np.random.randint(2,10,size = [2,5]))#整数
生成的随机数组为：
[[4 3 3 2 6]
[5 3 4 7 7]]
#下标索引
arr = np.arange(10)
arr
Out[91]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#用整数作为下标可以获取数组中的某个元素
print('索引结果为：',arr[5])#获取下标为5的元素，python下标从0开始
索引结果为： 5
print('索引结果为：',arr[3:5])#用范围作为下标获取数组的一个切片，含前不含后，包括arr[3]不包括arr[5]
索引结果为： [3 4]
print('索引结果为：',arr[:5]) #省略开始下标，表示从arr[0]开始
索引结果为： [0 1 2 3 4]
print('索引结果为：',arr[-1])#下标可以使用负数，-1表示从数组后往前数的第一个元素
索引结果为： 9
print('索引结果为：',arr[:-1])
索引结果为： [0 1 2 3 4 5 6 7 8]
arr[2:4] = 100,101#下标还可以用来修改元素的值
print('索引结果为：',arr)
索引结果为： [ 0 1 100 101 4 5 6 7 8 9]
print('索引结果为：',arr[1:-1:2])#范围中的第三个参数表示步长，2表示隔一个元素取一个元素
索引结果为： [ 1 101 5 7]
print('索引结果为：',arr[5:1:-2]) #步长为负数时，开始下标必须大于结束下标
索引结果为： [ 5 101]
arr = np.array([[1, 2, 3, 4, 5],[4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print('创建的二维数组为：\n',arr)
创建的二维数组为：
[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]]
print('索引结果为：\n',arr[0,3:5]) #索引第0行中第4和第5列的元素
索引结果为：
[4 5]
print('索引结果为：\n',arr[1:,2:]) #索引第2和第3行中第3列、第4列和第5列的元素
索引结果为：
[[ 6 7 8]
[ 9 10 11]]
print('索引结果为：\n',arr[:,2]) #索引第3列的元素
索引结果为：
[3 6 9]
print('索引结果为：',arr[[(0,1,2),(1,2,3)]]) #从两个序列的对应位置取出两个整数组成下标：arr[0,1], arr[1,2], arr[2,3]
索引结果为： [ 2 6 10]
print('索引结果为：',arr[1:,(0,2,3)]) #索引第2、3行中第1、3、4列的元素
索引结果为： [[ 4 6 7]
[ 7 9 10]]
mask = np.array([1,0,1],dtype = np.bool)
print('索引结果为：',arr[mask,2])#mask是一个布尔数组，它索引第1、3行中第3列的元素
索引结果为： [3 9]
#数组维度
arr = np.arange(12).reshape(3,4)
print('创建的二维数组为：\n',arr)
创建的二维数组为：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
print('数组维度为：\n',arr.ndim)#数组的维度
数组维度为：
2
数组展平后为：
[ 0 1 2 3 4 5 6 7 8 9 10 11]
print('数组展平后为：\n',arr.ravel())#展平
print('数组展平为：\n',arr.flatten()) #横向展平
数组展平为：
[ 0 1 2 3 4 5 6 7 8 9 10 11]
print('数组展平为：\n',arr.flatten('F')) #纵向展平
数组展平为：
[ 0 4 8 1 5 9 2 6 10 3 7 11]
创建的数组1为：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
print('创建的数组1为：\n',arr1)
arr2 = arr1*3
print('创建的数组2为：',arr2)
创建的数组2为： [[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
横向组合为： [[ 0 1 2 3 0 3 6 9]
[ 4 5 6 7 12 15 18 21]
[ 8 9 10 11 24 27 30 33]]
print('横向组合为：',np.concatenate((arr1,arr2),axis = 1)) #concatenate函数横向组合
纵向组合为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
横向组合为： [[ 0 1 2 3 0 3 6 9]
[ 4 5 6 7 12 15 18 21]
[ 8 9 10 11 24 27 30 33]]
print('纵向组合为：',np.concatenate((arr1,arr2),axis = 0)) #concatenate函数纵向组合
纵向组合为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
arr = np.arange(16).reshape(4,4)
print('创建的二维数组为：',arr)
创建的二维数组为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
横向分割为： [array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
print('横向分割为：',np.hsplit(arr, 2)) #hsplit函数横向分割
print('纵向分割为：',np.vsplit(arr, 2)) #vsplit函数纵向分割
纵向分割为： [array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
横向分割为： [array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
print('横向分割为：',np.split(arr, 2, axis=1)) #split函数横向分割
print('纵向分割为：',np.split(arr, 2, axis=0)) #split函数纵向分割
纵向分割为： [array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]