目录：1.掌握NumPy数组对象ndaray
1.1 创建数组对象
1.1.1 数组属性
1.2 生成随机数
1.3 通过索引访问数组
1.4 变换数组的形态
1.掌握NumPy数组对象ndaray
1.1 创建数组对象
1.1.1 数组属性
数组的属性及其说明
1.1.2数组创建
NumPy提供的array函数可以创建一维或多维数组，基本使用语法如下：
numpy.array(object,dtype=None,copy=True,order='K',subok=False,ndmin=0)
array函数的主要参数及其说明
创建数组并查看数组属性：
In[1]: import numpy as np #导入NumPy库
arr1 = np.array([1, 2, 3, 4]) #创建一维数组
print('创建的数组为：','arr1')
Out[1]: 创建的数组为：[1 2 3 4]
In[2]: #创建二维数组
arr2 = np.array([1, 2, 3, 4],[4, 5, 6, 7],[7, 8, 9, 10])
printf('创建的数组为：\n',arr2)
Out[2]: 创建的数组为：
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]]
In[3]: printf('数组维度为：',arr2.shape) #查看数组结构
Out[3]: 数组维度为： （3, 4）
In[4]: printf('数组类型为：',arr2.dtype) #查看数组类型
Out[4]: 数组类型为：int32
In[5]: printf('数组元素个数为：',arr2.size) #查看数组元素个数
Out[5]: 数组元素个数为：12
In[6]: printf('每组元素大小为：'，arr2.itemsize) #查看数组每个元素的大小
Out[6]: 数组每个元素大小为：4
重新设置数组的shape属性：
In[7]: arr2.shape = 4,3 #重新设置shape
print('重新设置shape后的arr2为：'，arr2)
Out[7]: 重新设置shape后的arr2为：[[ 1 2 3]
[ 4 4 5]
[ 6 7 7]
[ 8 9 10]]
使用arange函数创建数组（通过指定开始值、终值和步长来创建一维数组，创建的数组不含终值）：
In[8]: print('使用arrange函数创建的数组为：\n',np.arange(0,1,0.1))
Out[8]: 使用arange函数创建的数组为：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
使用linspace函数创建数组（通过指定开始值、终值和元素个数来创建一维数组，默认设置包括终值）：
In[9]: print('使用lispace函数来创建的数组为：'，np.linspace(0, 1, 12))
Out[9]: 使用lispace函数创建的数组为：[0. 0.09090909 ... 1.]
使用logspace函数创建等比数列（生成1（10^0）~ 100（10^2）的20个元素的等比数列）：
In[10]: print('使用logspace函数创建的数列为：'，np.logspace(0, 2, 20))
Out[10]: 使用logspace函数创建的数列为：[ 1. 1.27427499 1.62377674 ... 61.58482111 78.47599704 100.]
使用zeros函数创建数组（zeros函数用来创建值全部为0的数组，即创建的数组值全部填充为0）：
In[11]: print('使用zeros函数创建的数组为：'，np.zeros((2,3)))
Out[11]: 使用zeros函数创建的数组为：[[ 0. 0. 0.]
[ 0. 0. 0.]]
使用eye函数创建数组（生成主对角线上的元素为1，其他的元素为0的数值，类似单位矩阵）：
In[12]: print('使用eye函数创建的数组为：'，np.eye(3))
Out[12]: 使用eye函数创建的数组为：[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
使用diag函数创建数组（创建类似对角线的数组，即除对角线以外的其他元素都为0，对角线上的元素可以是0或其他值）：
In[13]: print('使用diag函数创建的数组为：',np.diag([1,2,3,4]))
Out[13]: 使用diag函数创建的数组为：[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
使用ones函数创建数组（用来创建元素全部为1的数组，即创建的数组元素全部填充为1）：
In[14]: print('使用ones函数创建的数组为：'，np.ones((5,3)))
Out[14]: 使用ones函数创建的数组为：[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]
1.1.3 数组数据类型
NumPy的基本数据类型及其取值范围
数据类型转换
In[15]: print('转换结果为：'，np.float64(42)) #整型转换为浮点型
Out[15]: 转换结果为; 42.0
In[16]: print('转换结果为：',np.int8(42.0)) #浮点型转换为整型
Out[16]: 转换结果为： 42
In[17]: print('转换结果为：',np.bool(42)) #整型转换为布尔型
Out[17]: 转换结果为： True
In[18]: print('转换结果为：',np.bool(0)) #整型转换为布尔型
Out[18]: 转换结果为： False
In[19]: print('转换结果为：',np.float(True)) #布尔型转换为浮点型
Out[19]: 转换结果为：1.0
In[20]: print('转换结果为：',np.float(False)) #布尔型转换为浮点型
Out[20]: 转换结果为：0.0
1.2 生成随机数
random函数是最常见的生成随机数的方法：
In[25]: print('生成的随机数组为：',np.random(100))
Out[25]: 生成的随机数组为：[ 0.15343184 0.51581585 0.07228451 ... 0.24418316 0.92510545 057507965]
rand函数可以生成服从均匀分布的随机数：
In[26]: print('生成的随机数组为：\n',np.random.rand(10,5))
Out[26]: 生成的随机数组为：[[0.39830491 0.94011394 0.59974923 0.44453894 0.65451838]
[0.72715001 0.07239451 0.03326018 0.13753806 0.44939676]
...
[0.75647074 0.03379595 0.39187843 0.58779075 0.91797808]
[0.1468544 0.82972989 0.58011115 0.45157667 0.32422895]]
注：每次运行代码后生成的随机数组都不一样，此处部分结果已经省略
生成服从正态分布的随机函数：
In[27]: print('生成的随机数组为：\n',np.random.randn(10,5))
Out[27]: 生成的随机数组为：
[[-0.60571968 0.39034908 -1.63315513 0.02783885 -1.84139301]
[-0.38700901 0.10433949 -2.62719644 -0.97863269 -1.18774802]
...
[-1.88050937 -0.97885403 -0.51844771 -0.51844771 -0.79439271 -0.83690031]
[-0.27500487 1.41711262 0.6635967 0.35486644 -0.2670073]]
注：每次运行代码后生成的随机数组都不一样，此处部分结果已经省略
randint函数可以生成给定上下限范围的随机数，其格式如下：
numpy.random.randint(low,high=None,size=None,dtype='1')
In[28]: print('生成的随机数组为：',np.random.randint(2,10,size = [2,5]))
Out[28]: 生成的随机数组为：[[6 6 6 6 8]
[9 6 6 8 4]]
返回值为最小值不低于2、最大值不高于10的2行5列数组。
random模块的常用随机数生成函数
1.3 通过索引访问数组
1.3.1 一维数组的索引
In[29]: arr = np.arange(10)
print('索引结果为：',arr[5]) #用整数作为下标可以获取数组中的某个元素
Out[29]: 索引结果为: 5
In[30]: #用范围作为下标获取数组的一个切片，包括arr[3],不包括arr[5]
print('索引结果为：',arr[3:5])
Out[30]: 索引结果为：[3,4]
In[31]: print('索引结果为：',arr[ :5]) #省略开始下标，表示从arr[0]开始
Out[31]: 索引结果为：[0 1 2 3 4]
In[32]: #下标可以使用负数，-1表示从数组最后往前数的第一个元素
print('索引结果为：',arr[-1])
Out[32]: 索引结果为：9
In[33]: arr[2:4] = 100,101
print('索引结果为：',arr) #下标还可以用来修改元素的值
Out[33]: 索引结果为：[ 0 1 100 101 4 5 6 7 8 9]
In[34]: #范围中的第三个参数表示步长，2表示隔一个元素取一个元素
print('索引结果为：',arr[1:-1:2])
Out[34]: 索引结果为：[ 1 101 5 7]
In[35]: print('索引结果为：',arr[5:1:-2]) #步长为负数时，开始下标必须大于结束下标
Out[35]: 索引结果为：[ 5 101]
1.3.2 多维数组的索引
In[36]: a = np.arange(24).reshape((2,3,4))
a
Out[36]: array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
In[37]: a[0,1,2]
Out[37]: 6
In[38]: a[-1,-2,-3]
Out[38]: 17
In[39]: arr = np.array([1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11])
print('创建的二维数组为：',arr)
Out[39]: 创建的二维数组为：[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]]
In[40]: arr[0,3:5]
Out[40]: [4 ,5]
In[41]: arr[1:,2:]
Out[41]: [ 6, 7, 8]
[ 7 ,10 ,11]
In[42]: arr[:,2]
Out[42]: [3 ,6 ,9]
In[43]: arr[1:,(0,2,3)]
Out[43]: [[ 4, 6, 7]
[ 7 ,9 ,10]]
In[44]: mask = np.array([1,0,1],dtype = np.bool)
print('索引结果为：',arr[mask,2])
Out[44]: 索引结果为：[3,9]
1.4 变换数组的形态
改变数组形状：
In[45]: arr = np.arange(12)
Out[45]: [ 0 ,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
In[46]: arr.reshape(3,4)
Out[46]: [[ 0, 1, 2, 3]
[ 4, 5, 6, 7]
[ 8, 9, 10, 11]]
In[47]: print('查看数组维度为：',arr.reshape(3,4).ndim) #查看数组维度
Out[47]: 数组维度为：2
使用ravel函数展平数组：
In[48]: arr = np.arange(12).reshape(3,4)
Out[48]: [[ 0, 1, 2, 3]
[ 4, 5, 6, 7]
[ 8, 9, 10, 11]]
In[49]: arr.ravel()
Out[49]: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
使用flatten函数展平数组：
In[50]: arr.flatten() #横向展平
Out[50]: [ 0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
In[51]: arr.flatten('F') #纵向展平
Out[51]: [ 0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11]
使用hstack函数实现横向组合：
In[52]: arr1 = np.arange(12).reshape(3,4)
Out[52]: [[0,1,2,3]
[4,5,6,7]
[8,9,10,11]]
In[53]: arr2 = arr1*3
Out[53]: [[0,3,6,9]
[12,15,18,21]
[24,27,30,33]]
In[54]: np.hstack(arr1,arr2)
Out[54]: [[0,1,2,3,0,3,6,9]
[4,5,6,7,12,15,18,21]
[8,9,10,11,24,27,30,33]]
使用vstack函数实现纵向组合：
In[55]: np.vstack((arr1,arr2))
Out[55]: [[0,1,2,3]
[4,5,6,7]
[8,9,10,11]
[0,3,6,9]
[12,15,18,21]
[24,27,30,33]]
使用concatenate函数组合数组：
In[56]: np.concatenate((arr1,arr2),axis = 1) #横向组合
Out[56]: [[0,1,2,3,0,3,6,9]
[4,5,6,7,12,15,18,21]
[8,9,10,11,24,27,30,33]]
In[57]: np.concatenate((arr1,arr2),axis = 0) #纵向组合
Out[57]: [[0,1,2,3]
[4,5,6,7]
[8,9,10,11]
[0,3,6,9]
[12,15,18,21]
[24,27,30,33]]
使用hsplit函数实现数组横向分割：
In[58]: arr = np.arange(16).reshape(4,4)
Out[58]: [[0,1,2,3]
[4,5,6,7]
[8,9,10,11]
[12,13,14,15]]
In[59]: np.hsplit(arr1,2)
Out[59]: array([[0,1],
[4,5],
[8,9],
[12,13]]),array([[2,3],
[6,7],
[10,11],
[14,15]])
使用vsplit函数实现数组纵向分割：
In[60]: np.vsplit(arr,2)
Out[60]: array([[0,1,2,3],
[4,5,6,7]]),array([[8,9,10,11],
[12,13,14,15]])
使用split函数分割数组：
In[61]: np.split(arr,2,axis = 1) #横向分割
Out[61]: array([[0,1],
[4,5],
[8,9],
[12,13]]),array([[2,3],
[6,7],
[10,11],
[14,15]])
In[62]: np.split(arr,2,axis = 0)
Out[62]: array([[0,1,2,3],
[4,5,6,7]]),array([[8,9,10,11],
[12,13,14,15]])
由于写这时没有软件,可能会存在格式不规范等问题