认识Numpy—数组

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