'''Numpy模块是Python语言的一个科学计算的第三方模块，其名字由Numerical Python缩写而成。
NumPy模块可以构建多维数据的容器，将各种类型的数据快速地整合在一起，完成多维数据的计算及大型矩阵的存储和处理'''
#导入Numpy模块，并购简写为np
import numpy as np
#创建数组
'''Numpy模块最主要的特点就是引入了数组的概念，数组是一些想同类型数据的集合，这些数据按照一定的顺序排列，并且每个数据占用大小相同的存储空间。
要使用数组组织数据，首先就要创建数组，NumPython模块提供多种创建数组的方法，创建的数组类型也多种多样。
'''
#使用array()函数创建数组
'''创建属猪最常用的方法是使用array()函数，该函数可基于序列型的对象（如列表、元组、集合等，还可以是一个已创建好的数组）创建任意维度的数组'''
a=np.array([1,2,3])
b=np.array(['编号','销量','单价'])
#使用array()函数基于列表创建一维数组，同一个数组中各元素的数据类型必须相同，比如a数组全是整形数字，b数组的元素都是字符串
print(a)
print(b)
#从运行结果可以看到，数组中的元素是通过空格分隔的
#要创建多维数组，可以为array()函数传入一个嵌套列表作为参数
c=np.array([[1,2,3],[6,6,6]])
print(c)
'''
#创建了一个2行3列的数组
[[1 2 3]
 [6 6 6]]
 '''
'''array()函数的语法格式与参数含义：
array(object,dtype=None,copy=True,order=None,subok=False,ndmin=0)
'''
print('-------------创建等差数组-----------------')
'''如果要创建的数组中的元素能构成一个等差序列，那么使用arange()函数创建数组会更方便'''
d=np.arange(1,20,2)
#生成起始值为1，结束值为20（不包含该数值），步长为20的等差序列，然后用这个等差序列创建一维数组
print(d)    #[ 1  3  5  7  9 11 13 15 17 19]    #每个元素相差2
#如果省略arange函数的第3个参数，则步长默认为1
d=np.arange(1,20)
print(d)    #[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
#如果arange函数中只有一个参数，则arange函数将此参数作为结束值，起始值默认为0，步长默认为1
d=np.arange(10)
print(d)    #[0 1 2 3 4 5 6 7 8 9]
print('-----------创建随机数组-------------------')
'''可以使用Numpy模块的子模块random中的函数创建随机数的数组，包括：
rand(),randn(),randint()'''
#rand()函数创建的数组中，每个元素都是0和1之间的随机数
e=np.random.rand(3) #创建一个有3个元素的一维数组，每个元素都是0和1之间的随机数
print(e)    #[0.89497172 0.22727479 0.62424915]
print('---')
#如果给rand()函数传入一对参数值，就会生成一个相应行、列数的二维数组
e=np.random.rand(2,3)   #2行3列
print(e)
'''
[[0.47418429 0.34766982 0.3966129 ]
 [0.82166887 0.15501558 0.03012495]]
'''
print('---randn()函数---')
'''用randn()函数创建的数组中的元素是符合标准正态分布（均值为0，标准差为1）的随机数'''
e=np.random.randn(3)
print(e)    #[-0.30353234  1.79359807 -2.68410643]
print('---')
#如果randn()函数有两个参数，则生成对应行与列的二维数组，且数组元素符合标准正态分布
e=np.random.randn(2,3)  #2行3列的元素符合正态分布的数组
print(e)
'''
[[ 0.46590471  0.12698243 -0.98544711]
 [-0.48227728  0.8829481   0.67915826]]
 '''
print('-------randint()函数---------')
'''randint()函数可以创建指定范围内的随机整数的数组'''
e=np.random.randint(1,10,2) #创建1到10之间的随机整数，不包括10，创建2个
print(e)
print('---')
#randint()也可以创建二维随机整数数组
e=np.random.randint(1,10,(2,3)) #最后一个参数代表2行3列
print(e)
'''
输出结果是：
[[9 2 8]
 [5 3 9]]
 '''
print('---')
print('--------------查看数组的属性---------------------------')
'''数组的属性主要是指数组的行列数、元素个数、元素的数据类型、数组的维数。'''
#数组的shape属性用于查看数组的行数和列数
arr=np.array([[1,2],[2,3],[6,6]])
print(arr)
'''
[[1 2]
 [2 3]
 [6 6]]
'''
print('---')
print(arr.shape)    #(3, 2) #代表3行2列
'''通过shape属性获得的是元组，如果只想查看数组的行数或列数，
可以通过从元组中提取元素来实现'''
print(arr.shape[0]) #3
print(arr.shape[1]) #2
'''shape()函数将数组的行数与列数信息生成了一个元组，提取元组的第一个元素，相当于查看arr的行数，提取元组中第二个元素，相当于查看arr的列数
'''
print('---数组的size属性可以查看数组元素个数---')
arr=np.array([1,2,3])
print(arr.size) #3  #表示数组中有3个元素
#数组的dtype属性可以查看数组的数据类型
arr=np.array([[1,2,3],[6,6,6]])
print(arr.dtype)    #int32
arr=np.array([[1.2,2.3,3.3],[6,6,6]])
print(arr.dtype)    #float64    表示该数组的数据类型是浮点型数字
#可以通过astype()函数转换数组的数据类型
arr=np.array([[1.9,3,3.3],[6,6,6]])
print(arr)
arr2=arr.astype(int)
print(arr2)
'''
将浮点型数字转换成了整形数字，注意1.9转换成了1，只保留整数部分
[[1 3 3]
 [6 6 6]]
'''
print(arr2.dtype)   #int32
#ndim属性可以查看数组的维数
arr=np.array([[1,2,3],[2,3,3],[6,6,3]])
print(arr.ndim) #2  #二维数组
print('-----------选取数组元素----------------------')
'''数组元素可以通过数组的索引值和切片功能来选取'''
#一维数组的元素选取
'''一维数组的结构比较简单，数组元素的选取也比较简单，既可以选取单个元素，也可以选取多个连续的元素，还可以按照一定的规律选取多个不连续的元素'''
print('''---选取单个元素---''')
'''在一维数组中选取单个元素的方法非常简单，直接根据数组元素的索引值来选取即可。
正序索引时，索引值从0开始，倒序索引，索引值从-1开始
'''
arr=np.array([1,2,3,4,5,6,7])
print(arr[0])   #1
print(arr[2])   #3
print(arr[-1])  #7
#选取连续的元素
'''如果想要在一个数组中选取多个连续的元素，给出起始位置与结束为止的索引值即可。
需要注意的是，起始位置和结束为止的索引值构成的是一个“左闭右开”的区间，
也就是说，选取起始位置的元素，但不选取结束位置的元素
'''
arr=np.array([1,2,3,4,5,6,7])
print(arr[0:2]) #[1 2]   # 选取从索引值0开始、在索引值2之前的元素
print(arr[0:-1])    #[1 2 3 4 5 6]    #选取索引值从0开始，以及倒数第一之前的元素
print(arr[:3])  #[1 2 3]    选取索引值3之前的元素
print(arr[:-3]) #[1 2 3 4]  #选取倒数第三个元素之前的元素
print(arr[1:])  #[2 3 4 5 6 7]  #选取索引值从1开始，以及它后面的所有元素
print(arr[-3:]) #[5 6 7]    #选取从倒数第三个开始以及它后面的所有元素
print('---')
#选取不连续的元素
'''如果想在指定的区间中，每隔几个元素就取其中一个元素，可以使用数组切片的方式来实现'''
arr=np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])
print(arr[1:16:10])      #[ 2 12]   #从索引值1开始，到索引值16之前的元素中，每10个取第一个
print(arr[16:1:-10])    #[17  7]    #第3个数字是负数，表示反向选取，从索引值16开始，到索引值1之后的元素中，每10个取第一个
print(arr[::10])    #[ 1 11]      #省略了起始位置与结束位置的索引值，表示从头到尾每10个元素取第一个元素
print(arr[::-10])   #[17  7]    #表示从末尾到开头，每10个元素取第一个元素
print(arr[::-1])   #[17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1]
#从末尾到开头，反向选取每一个元素
print(arr[2::]) #[ 3  4  5  6  7  8  9 10 11 12 13 14 15 16 17]
# #省略了结束位置与步长参数，表示选取从索引值2的元素开始以及之后的所有元素
print(arr[:2:]) #[1 2]  #省略起始索引值与步长参数，表示选取索引值2之前的所有元素
print('---')
#print(arr[::0])
print(arr[::1]) #选取每一个元素
print(arr[::2]) #每2个元素选取第一个元素
print('--------------二维数组的元素选取-------------')
'''二维数组中元素的选取与一维数组中元素的选取类似，也是基于索引值进行的，
但是要用英文逗号【,】分隔数组的行和列的索引值'''
#选取单个元素
'''如果要选取二维数组中的某个元素，直接传入元素在数组中的行和列的索引值即可'''
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
'''
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
'''
print(arr)
print('---')
print(arr[1,2])  #6  #索引值1（第二行），索引值2（第三列）的元素
#选取单行或单列的元素，直接指定这一行或这一列的索引位置即可
print(arr[2])   #[7 8 9]    #arr中索引值是2的元素（第三行）
print(arr[2,:]) #[7 8 9]    #arr中索引值是2的元素（第三行）
print(arr[:,2]) #[ 3  6  9 12]  #选取所有行中索引值是2的元素，也就是选取第3列
'''在选取单列时，[]中的逗号前必须得有一个英文冒号，
当冒号前后没有参数时，表示选取所有行，随后再选取指定列。
其实在选取单行时，也可以在[]中输入逗号和冒号，
也就是说之前选取行的代码可以改为print(arr[2,:])'''
print('---')
#选取某些行或某些列的元素
'''如果要选取某些行的元素，指定这些行的索引值区间即可，选取时同样遵循“左闭右开”规则'''
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
'''
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
'''
print(arr[1:3])     #选取索引值1,到 索引值3元素之前的元素，也就是选取第一行与第二行
'''[[4 5 6]
 [7 8 9]]'''
print(arr[:2])  #选取索引值2元素之前的元素
'''[[1 2 3]
 [4 5 6]]'''
print(arr[2:])  #选取索引值2以及2之后的所有元素
'''[[ 7  8  9]
 [10 11 12]]
'''
print('---')
#选取某些列的元素
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
'''
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
'''
print(arr[:,1:3])   #选取每一行中，第2列到第4列之前（第三列）的元素
'''
[[ 2  3]
 [ 5  6]
 [ 8  9]
 [11 12]]'''
print(arr[:,2]) #[ 3  6  9 12]  #选取每一行中，索引值是2的元素
print(arr[:,1:])    #选取每一行中，从索引值1的元素开始，到最后一个元素
'''
[[ 2  3]
 [ 5  6]
 [ 8  9]
 [11 12]]
'''
print('---')
print(arr[0:2,1])   #[2 5]  #选取第索引值从0到索引值2之前的每一行，中的索引值为1的元素
print('---')
#要同时选取行和列的元素，同时给出要选取的行和列的索引值即可
print(arr[0:2,1:3])
#选取从索引值0开始，到索引值2之前的每一行，中的索引值从1开始，索引值3之前的元素
#第一行与第二行中的，第2个到第4个之前的元素
'''
[[2 3]
 [5 6]]'''
#数组的重置与转置
'''
数组的重置是指更改数组的形状，也就是将某个维度的数组转换成另一个维度的数组，例如，将一维数组转换为多维数组，或者将3行4列的 二维数组转换成4行3列的二维数组。
转置是重塑的一种特殊形式，是指将数组的行旋转为列，列旋转为行。
无论是数组重塑还是数组转置，操作前后的数组元素个数都是不会改变的。
'''
print('-----------------------一维数组的重塑-------------------')
'''
Numpy模块中的reshape()函数，可以在不改变数组元素内容和个数的情况下，重塑数组的形状。
在进行数组重塑时，新数组的形状应该与原数组的形状相兼容，比如9个元素的一维数组可以转换成3行3列的数组，但不能转换成2行2列的数组， 即新数组的形状不能导致元素的个数发生改变，否则会报错。
要将一个有12个元素的一维数组转换为二维数组，则二维数组的形状只能是：
1行12列、2行6列、3行4列、4行3列、6行2列、12行1列
'''
'''一维数组的重塑就是将一行或一列的数组转换成多行多列的数组'''
arr=np.array([1,2,3,4,5,6])
a=arr.reshape(2,3)  #将数组转换成2行3列，并将结果赋值给a
print(a)
'''
[[1 2 3]
 [4 5 6]]
'''
a=arr.reshape(3,2)  #将数组转换成3行2列
print(a)
'''
[[1 2]
 [3 4]
 [5 6]]
'''
print('----------多维数组的重塑--------------')
'''reshape()函数除了可以将一维数组转换为多维数组，还可以更改多维数组的形状'''
arr=np.array([[2,2,2,2],[3,3,3,3],[6,6,6,6]])
c=arr.reshape(2,6)  #转换成二行六列并赋值给C
print(c)
'''
[[2 2 2 2 3 3]
 [3 3 6 6 6 6]]'''
print('----------将多维数组转换为一维数组------------------')
arr=np.array([[2,2,2],[3,3,3]])
print(arr.flatten())    #[2 2 2 3 3 3]
print(arr.ravel())  #[2 2 2 3 3 3]
print('--------数组的转置------------------')
'''NumPy模块提供了T属性和transpose()函数两种方法用于数组的转置'''
#T属性
'''T属性的用法很简单，只需要在转置的数组后调用T属性即可,
可以将行转换成列，列转换成行
'''
arr=np.array([[2,2,2],[3,3,3]])
print(arr)
print('---')
print(arr.T)
'''
[[2 3]
 [2 3]
 [2 3]]'''
print('---')
# transpose()函数
'''transpose()函数时通过调换数组的行和列的索引值来转置数组的'''
arr=np.array([[2,2,2],[3,3,3]])
arr1=np.transpose(arr)
print(arr1)
'''
从2行3列转换成3行2列
[[2 3]
 [2 3]
 [2 3]]'''
print('-------------数组的处理--------------------')
'''数组的常见处理操作包括在数组中添加或删除元素、处理数组中的缺失值和重复值、对数组进行拼接和拆分等'''
print('---------添加数组元素----------')
'''使用NumPy模块中的append()函数和insert()函数可以方便地在数组中添加元素'''
print('-------append()函数---------')
#append()函数可以在数组的末尾添加元素
arr=np.array([[2,2,2],[3,3,3]])
arr1=np.append(arr,[[6,6,6]])
print(arr1) #[2 2 2 3 3 3 6 6 6]
#通过append()函数在数组的末尾添加元素后，二维数组变成了一维数组
'''想要使用append()函数往数组中添加元素，又不想改变数组的维度，可以在append()函数中加入一个axis=0的参数,
我们可以简单地理解为，元素会添加在数组的行方向上，
也就是说，数组的行数会增加，但列数不变'''
arr2=np.append(arr,[[6,6,6]],axis=0)
print(arr2)
'''
[[2 2 2]
 [3 3 3]
 [6 6 6]]'''
print('---')
'''axis参数也可以设置为1，表示元素会添加在数组的列方向上，
也就是说，数组的列数会增加，但行数不变。
添加的列数要与原数组的列数相契合，原数组有2列，那么添加1列就会报错'''
arr3=np.append(arr,[[6,6,6],[9,9,9]],axis=1)
print(arr3)
'''[[2 2 2 6 6 6]
 [3 3 3 9 9 9]]'''
#数组从2行3列变为2行6列，数组的维度和行数没有变化，但列数和元素个数却增加了
'''
append()函数的用法
append(arr,values,axis=None)
参数          说明
arr         要添加元素的数组（必须）
values  要添加进数组的数组元素(必须)
axis    省略该参数时，默认为None，表示在数组的末尾添加元素，但数组会转换成一个而一位数组（返回一个一维数组）；当axis值为0，表示在行方向上添加元素，值为1则表示在列方向上添加元素
'''
print('---------insert()函数--------')
'''insert函数表示在数组的指定位置插入元素'''
arr=np.array([[2,2,2],[3,3,3]])
arr1=np.insert(arr,1,[6,6],axis=None) #在索引值为1的位置插入指定元素，且转换成了一维数组
print(arr1) #[2 6 6 2 2 3 3 3]
'''与append()函数一样，insert()函数在插入元素后，默认也会将它转换为一维数组，
想要不改变数组的维度，同样也需要axis参数
axis为0，表示在行方向的指定位置插入元素，也就是说行数会增加但列数不变,注意如果每行有几个元素（列），添加的行中也得有几个元素（列），否则会报错
axis为1，表示在列方向上的指定位置插入元素，列数会增加但行数不会改变,注意原数组有几行，那么添加的数组也只能有几个元素，比如原数组有2行，那么添加的数组也只能有2个元素，要是往一个只有2行的数组，在axis=1的情况下，往3行里插入元素，就会报错'''
arr2=np.insert(arr,1,[6,6,6],axis=0)
print(arr2)
'''
[[2 2 2]
 [6 6 6]
 [3 3 3]]'''
print('---')
arr3=np.insert(arr,1,[[6,6]],axis=1)
print(arr3)
'''
[[2 6 2 2]
 [3 6 3 3]]'''
'''insert()函数的参数说明
参数          说明
arr         需要插入元素的数组（必须）
obj         数组的索引值，即需要在哪个位置插入元素（必须）
values      需要插入的元素（必须）
axis        默认为None,当省略该参数时，会将数组先展开为一维数组，然后在一维数组的指定位置插入元素；当值为0时，表示在行方向的指定位置插入元素，当值为1时，表示在列方向的指定位置插入元素
'''
print('--------删除数组元素-----------------')
'''删除数组元素需要用到NumPy模块中的delete()函数
如果没填写axis值，则默认先将数组转换为一维数组，再删除指定索引值的元素
axis值为0，则删除指定索引值的行，axis值为1，则删除指定索引值的列
'''
arr=np.array([[1,2,3],[4,5,6]])
arr1=np.delete(arr,2)   #转换为一维数组并删除索引值为2的元素
print(arr1) #[1 2 4 5 6]
print('---')
arr2=np.delete(arr,1,axis=0)    #axis值为0，删除索引值为1的行（第二行）
print(arr2) #[[1 2 3]]
print('---')
arr3=np.delete(arr,0,axis=1)    #删除索引值为1的列
print(arr3)
'''
[[2 3]
 [5 6]]'''
print('---------处理数组的缺失值------------')
'''数组的缺失值处理可分两步进行，先找到缺失值的位置，然后用指定的值填充
NumPy模块中的isnan()函数可以标记数组中缺失值的位置'''
arr=np.array([0,np.nan,2])  #np.nan表示缺失值
print(arr)  #[ 0. nan  2.]  #输出含有缺失值的数组arr
print(np.isnan(arr))    #[False  True False]
#用isnan()函数标记缺失值的位置，是缺失值则标记True,没有缺失值则标记False
'''找到缺失值后，可以用isnan()函数对缺失值进行填充'''
arr[np.isnan(arr)]=1    #对arr数组有缺失值的位置填充数字1
print(arr)  #[0. 1. 2.]
print('--------处理数组的重复值---------')
'''使用NumPy模块的unique()函数即可处理重复值，
该函数除了会去除数组中的重复元素，还会将去重后的数组元素从小到大排列'''
arr=np.array([1,1,0,0,2])
arr1=np.unique(arr) #调用unique()函数对数组去重处理
print(arr1) #[0 1 2]
print('---')
arr1,arr2=np.unique(arr,return_counts=True) #return_counts=True用于查看去重后数组中的元素在原数组中出现的次数
print(arr1) #[0 1 2]    #去重后并按照从小到大排列的效果，
print(arr2) #[2 2 1]    #去重之后的数组中的每个元素，在原数组中出现的次数，比如0在原数组中出现2次就显示2
print('---------拼接数组----------------')
'''数组的拼接是指将多个数组合并为一个数组，可以使用NumPy模块中的concatenate()、hstack()、vstack()函数实现，
需要注意的事待合并的几个数组的维度必须相同，
即一维数组智能与一维数组合并，二维数组智能与二维数组合并。
如果是一维数组之间的合并，那么数组的形状可以不一样，
如果是多维数组之间的合并，那数组的形状则必须要相同，也就是数组之间的行数与列数保持一致'''
#concatenate()函数
'''concatenate()函数一次能合并多个数组，是数组拼接最常用的方法,
axis参数用于指定数组拼接的方向，
省略axis参数或axis值设为0，表示在列的方向上拼接，
在列方向上拼接后的数组行数，是原先多个数组的行数之和，而列数不会改变，
相当于将第二个数组直接追加到第一个数组之后，然后生成一个新的数组？
axis值为1表示在行的方向上拼接，也就是说新的合成对象的内容，第一行是将原来的第一个数组的第一行与第二个数组的第一行合并来的，以此类推
在行方向上拼接后的数组行数不会改变，而列数是原先多个数组的列数之和'''
arr1=np.array([[1,1,1],[2,2,2]])
arr2=np.array([[6,6,6],[7,7,7]])
arr3=np.concatenate((arr1,arr2),axis=0)
print(arr3)
'''
[[1 1 1]
 [2 2 2]
 [6 6 6]
 [7 7 7]]'''
print('---')
arr6=np.concatenate((arr1,arr2),axis=1)
print(arr6)
'''
[[1 1 1 6 6 6]
 [2 2 2 7 7 7]]'''
print('-------hstack()函数和vstack()函数-------------')
'''
hstack()函数能以水平堆叠的方式拼接数组，其效果相当于concatenate()函数在行方向上拼接数组；
vstack()函数能以垂直堆叠的方式拼接数组，其效果相当于concatenate()函数在列方向上拼接数组'''
arr1=np.array([[1,1,1],[2,2,2]])
arr2=np.array([[3,3,3],[6,6,6]])
print('---')
hhh=np.hstack((arr1,arr2))
print(hhh)
'''
[[1 1 1 3 3 3]
 [2 2 2 6 6 6]]'''
print('---')
arr1=np.array([[1,1,1],[2,2,2]])
arr2=np.array([[3,3,3],[6,6,6]])
vvv=np.vstack((arr1,arr2))
print(vvv)
'''
[[1 1 1]
 [2 2 2]
 [3 3 3]
 [6 6 6]]'''
print('-----------拆分数组--------------')
'''数组的拆分就是将一个数组分隔成多个数组，可以使用NumPy模块中的split()、hsplit()以及vsplit()函数'''
'''split函数可以按指定的份数将一个数组均分为多个数组，既可以将数组平均地拆分成指定的份数，
也可以按照指定的位置来拆分,如果按照指定的位置来拆分，需要在[]填入若干个索引值，在索引值之前的元素将被拆为一组，然后剩下所有的再合并成一组'''
arr=np.array([1,2,3,4,5,6,7,8,9,0,11,22])
arr1=np.split(arr,2)    #将一维数组拆分成2个大小相等的 一维数组
print(arr1) #[array([1, 2, 3, 4, 5, 6]), array([ 7,  8,  9,  0, 11, 22])]
print('---')
arr=np.array([0,1,2,3,4,5,6,7,8,9,11,22])
arr3=np.split(arr,[2,6]) #表示在arr数组的索引值2（第3个元素）与索引值6的元素之间进行拆分
print(arr3) #[array([0, 1]), array([2, 3, 4, 5]), array([ 6,  7,  8,  9, 11, 22])]
print('---')
arr6=np.split(arr,[2,7,9])   #索引值2之前的元素拆为一组、索引值7之前的拆为一组、索引值9之前的拆为一组，剩下的拆为一组
print(arr6) #[array([0, 1]), array([2, 3, 4, 5, 6]), array([7, 8]), array([ 9, 11, 22])]
print('---------hsplit()和vsplit()函数------------------')
'''hsplit()函数能将一个数组横向拆分成多个数组，
vsplit()函数能将一个数组纵向拆分成多个数组'''
arr1=np.array([[2,2,3],[3,3,3],[6,6,6],[7,7,7]])
arr2=np.hsplit(arr,2)   #横向拆分成2个数组
print(arr2) #[array([0, 1, 2, 3, 4, 5]), array([ 6,  7,  8,  9, 11, 22])]
print('---')
arr3=np.vsplit(arr1,2)
print(arr3)
'''
[array([[2, 2, 3],
       [3, 3, 3]]), array([[6, 6, 6],
       [7, 7, 7]])]'''
print('---------------数组的运算---------------------')
'''NumPy模块的优势不仅在于支持多个维度数据的存储和展示，它还能很好的支持数组的数学运算，如数组之间的四则运算和数组元素的统计运算'''
print('--------数组之间的四则运算-----------------')
'''对于多个形状一致的数组，我们可以直接对它们进行加减乘除等运算，
运算结果是一个由对应位置上的元素分别进行四则运算后的数组'''
arr1=np.array([[2,2,2],[3,3,3]])
arr2=np.array([[3,3,3],[6,6,6]])
arr3=arr1+arr2
print(arr3)
'''[[5 5 5]
 [9 9 9]]'''
print('---')
arr6=arr1*arr2
print(arr6)
'''
[[ 6  6  6]
 [18 18 18]]'''
#以上使用了加法和乘法运算，同样的还可以使用减法和除法运算
print('---')
#除了可以在多个数组之间进行四则运算，还可以对一个数组和一个数值进行四则运算
arr=np.array([[2,2,2],[3,3,3]])
arr2=arr+7
print(arr2)
'''
[[ 9  9  9]
 [10 10 10]]'''
print('---')
arr3=arr*10
print(arr3)
'''
[[20 20 20]
 [30 30 30]]
'''
print('---------数组元素的统计运算---------------')
'''使用NumPy模块中的一些函数可以对数组元素进行统计运算，比如求和、求平均值、求最大值和最小值等'''
print('--------求和-----------')
'''sum()函数用于求和，它除了能对整个数组的所有元素求和，它除了能对整个数组的所有元素求和，还能对数组的每一行或每一列元素分别求和,
不设置参数表示对整个数组的所有元素进行求和’
axis值为0表示每一列元素分别求和，也就是行与行之间对应位置的值相加，生成新的一行；
axis值为1表示每行各自求和，再把每行的和放在一起生成新的数组'''
arr=np.array([[2,2,6],[3,3,3]])
arr1=arr.sum()
print(arr1) #19
arr2=arr.sum(axis=0)
print(arr2) #[5 5 9]
arr3=arr.sum(axis=1)
print(arr3) #[10  9]
print('-----求平均值-----------')
'''mean()函数用于求平均值，它除了能对数组的所有元素求平均值，还能对数组的每一行或每一列元素分别求平均值，参数值用法与sum()函数一致'''
arr=np.array([[2,2,2],[3,3,3]])
arr1=arr.mean()
print(arr1) #2.5
print(arr.mean(axis=0)) #[2.5 2.5 2.5]
print(arr.mean(axis=1)) #[2. 3.]
print('----------求最值------------------')
'''max()函数和min()函数分别用于求数组元素的最大值和最小值。
与sum()函数和mean()函数类似，max()函数和min()函数也能通过设置参数来指定求最值的方式：
如果不设置参数，表示在整个数组范围内寻找最值；
axis值为0表示对数组的每一列元素分别求最大值；
axis值为1表示取每一行的最值，生成新的数组'''
arr=np.array([[0,9,3],[7,8,2]])
print(arr.max())    #9
print(arr.max(axis=0))  #[7 9 3]    #寻找每一列中的最大值，合成新的数组
print(arr.max(axis=1))  #[9 8]  #取每一行中各自的最大值，生成新的数组
generic
14.93 KB
© 李灵杰 /•᷅‎‎•᷄\୭
'''Numpy模块是Python语言的一个科学计算的第三方模块，其名字由Numerical Python缩写而成。
NumPy模块可以构建多维数据的容器，将各种类型的数据快速地整合在一起，完成多维数据的计算及大型矩阵的存储和处理'''

#导入Numpy模块，并购简写为np
import numpy as np

#创建数组
'''Numpy模块最主要的特点就是引入了数组的概念，数组是一些想同类型数据的集合，这些数据按照一定的顺序排列，并且每个数据占用大小相同的存储空间。
要使用数组组织数据，首先就要创建数组，NumPython模块提供多种创建数组的方法，创建的数组类型也多种多样。
'''

#使用array()函数创建数组
'''创建属猪最常用的方法是使用array()函数，该函数可基于序列型的对象（如列表、元组、集合等，还可以是一个已创建好的数组）创建任意维度的数组'''

a=np.array([1,2,3])
b=np.array(['编号','销量','单价'])
#使用array()函数基于列表创建一维数组，同一个数组中各元素的数据类型必须相同，比如a数组全是整形数字，b数组的元素都是字符串
print(a)
print(b)
#从运行结果可以看到，数组中的元素是通过空格分隔的


#要创建多维数组，可以为array()函数传入一个嵌套列表作为参数
c=np.array([[1,2,3],[6,6,6]])
print(c)
'''
#创建了一个2行3列的数组
[[1 2 3]
 [6 6 6]]
 '''

'''array()函数的语法格式与参数含义：
array(object,dtype=None,copy=True,order=None,subok=False,ndmin=0)
'''


print('-------------创建等差数组-----------------')
'''如果要创建的数组中的元素能构成一个等差序列，那么使用arange()函数创建数组会更方便'''
d=np.arange(1,20,2)
#生成起始值为1，结束值为20（不包含该数值），步长为20的等差序列，然后用这个等差序列创建一维数组
print(d)    #[ 1  3  5  7  9 11 13 15 17 19]    #每个元素相差2

#如果省略arange函数的第3个参数，则步长默认为1
d=np.arange(1,20)
print(d)    #[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

#如果arange函数中只有一个参数，则arange函数将此参数作为结束值，起始值默认为0，步长默认为1
d=np.arange(10)
print(d)    #[0 1 2 3 4 5 6 7 8 9]




print('-----------创建随机数组-------------------')
'''可以使用Numpy模块的子模块random中的函数创建随机数的数组，包括：
rand(),randn(),randint()'''

#rand()函数创建的数组中，每个元素都是0和1之间的随机数
e=np.random.rand(3) #创建一个有3个元素的一维数组，每个元素都是0和1之间的随机数
print(e)    #[0.89497172 0.22727479 0.62424915]
print('---')
#如果给rand()函数传入一对参数值，就会生成一个相应行、列数的二维数组
e=np.random.rand(2,3)   #2行3列
print(e)
'''
[[0.47418429 0.34766982 0.3966129 ]
 [0.82166887 0.15501558 0.03012495]]
'''

print('---randn()函数---')
'''用randn()函数创建的数组中的元素是符合标准正态分布（均值为0，标准差为1）的随机数'''
e=np.random.randn(3)
print(e)    #[-0.30353234  1.79359807 -2.68410643]
print('---')
#如果randn()函数有两个参数，则生成对应行与列的二维数组，且数组元素符合标准正态分布
e=np.random.randn(2,3)  #2行3列的元素符合正态分布的数组
print(e)
'''
[[ 0.46590471  0.12698243 -0.98544711]
 [-0.48227728  0.8829481   0.67915826]]
 '''

print('-------randint()函数---------')
'''randint()函数可以创建指定范围内的随机整数的数组'''
e=np.random.randint(1,10,2) #创建1到10之间的随机整数，不包括10，创建2个
print(e)
print('---')
#randint()也可以创建二维随机整数数组
e=np.random.randint(1,10,(2,3)) #最后一个参数代表2行3列
print(e)
'''
输出结果是：
[[9 2 8]
 [5 3 9]]
 '''
print('---')




print('--------------查看数组的属性---------------------------')
'''数组的属性主要是指数组的行列数、元素个数、元素的数据类型、数组的维数。'''

#数组的shape属性用于查看数组的行数和列数
arr=np.array([[1,2],[2,3],[6,6]])
print(arr)
'''
[[1 2]
 [2 3]
 [6 6]]
'''
print('---')
print(arr.shape)    #(3, 2) #代表3行2列
'''通过shape属性获得的是元组，如果只想查看数组的行数或列数，
可以通过从元组中提取元素来实现'''
print(arr.shape[0]) #3
print(arr.shape[1]) #2
'''shape()函数将数组的行数与列数信息生成了一个元组，提取元组的第一个元素，相当于查看arr的行数，提取元组中第二个元素，相当于查看arr的列数
'''

print('---数组的size属性可以查看数组元素个数---')
arr=np.array([1,2,3])
print(arr.size) #3  #表示数组中有3个元素

#数组的dtype属性可以查看数组的数据类型
arr=np.array([[1,2,3],[6,6,6]])
print(arr.dtype)    #int32

arr=np.array([[1.2,2.3,3.3],[6,6,6]])
print(arr.dtype)    #float64    表示该数组的数据类型是浮点型数字


#可以通过astype()函数转换数组的数据类型
arr=np.array([[1.9,3,3.3],[6,6,6]])
print(arr)
arr2=arr.astype(int)
print(arr2)
'''
将浮点型数字转换成了整形数字，注意1.9转换成了1，只保留整数部分
[[1 3 3]
 [6 6 6]]
'''
print(arr2.dtype)   #int32


#ndim属性可以查看数组的维数
arr=np.array([[1,2,3],[2,3,3],[6,6,3]])
print(arr.ndim) #2  #二维数组


print('-----------选取数组元素----------------------')
'''数组元素可以通过数组的索引值和切片功能来选取'''

#一维数组的元素选取
'''一维数组的结构比较简单，数组元素的选取也比较简单，既可以选取单个元素，也可以选取多个连续的元素，还可以按照一定的规律选取多个不连续的元素'''

print('''---选取单个元素---''')
'''在一维数组中选取单个元素的方法非常简单，直接根据数组元素的索引值来选取即可。
正序索引时，索引值从0开始，倒序索引，索引值从-1开始
'''
arr=np.array([1,2,3,4,5,6,7])
print(arr[0])   #1
print(arr[2])   #3
print(arr[-1])  #7

#选取连续的元素
'''如果想要在一个数组中选取多个连续的元素，给出起始位置与结束为止的索引值即可。
需要注意的是，起始位置和结束为止的索引值构成的是一个“左闭右开”的区间，
也就是说，选取起始位置的元素，但不选取结束位置的元素
'''
arr=np.array([1,2,3,4,5,6,7])
print(arr[0:2]) #[1 2]   # 选取从索引值0开始、在索引值2之前的元素
print(arr[0:-1])    #[1 2 3 4 5 6]    #选取索引值从0开始，以及倒数第一之前的元素
print(arr[:3])  #[1 2 3]    选取索引值3之前的元素
print(arr[:-3]) #[1 2 3 4]  #选取倒数第三个元素之前的元素
print(arr[1:])  #[2 3 4 5 6 7]  #选取索引值从1开始，以及它后面的所有元素
print(arr[-3:]) #[5 6 7]    #选取从倒数第三个开始以及它后面的所有元素


print('---')
#选取不连续的元素
'''如果想在指定的区间中，每隔几个元素就取其中一个元素，可以使用数组切片的方式来实现'''
arr=np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])
print(arr[1:16:10])      #[ 2 12]   #从索引值1开始，到索引值16之前的元素中，每10个取第一个
print(arr[16:1:-10])    #[17  7]    #第3个数字是负数，表示反向选取，从索引值16开始，到索引值1之后的元素中，每10个取第一个
print(arr[::10])    #[ 1 11]      #省略了起始位置与结束位置的索引值，表示从头到尾每10个元素取第一个元素
print(arr[::-10])   #[17  7]    #表示从末尾到开头，每10个元素取第一个元素
print(arr[::-1])   #[17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1]
#从末尾到开头，反向选取每一个元素

print(arr[2::]) #[ 3  4  5  6  7  8  9 10 11 12 13 14 15 16 17]
# #省略了结束位置与步长参数，表示选取从索引值2的元素开始以及之后的所有元素

print(arr[:2:]) #[1 2]  #省略起始索引值与步长参数，表示选取索引值2之前的所有元素
print('---')
#print(arr[::0])
print(arr[::1]) #选取每一个元素
print(arr[::2]) #每2个元素选取第一个元素




print('--------------二维数组的元素选取-------------')
'''二维数组中元素的选取与一维数组中元素的选取类似，也是基于索引值进行的，
但是要用英文逗号【,】分隔数组的行和列的索引值'''




#选取单个元素
'''如果要选取二维数组中的某个元素，直接传入元素在数组中的行和列的索引值即可'''
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
'''
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
'''
print(arr)
print('---')
print(arr[1,2])  #6  #索引值1（第二行），索引值2（第三列）的元素

#选取单行或单列的元素，直接指定这一行或这一列的索引位置即可
print(arr[2])   #[7 8 9]    #arr中索引值是2的元素（第三行）
print(arr[2,:]) #[7 8 9]    #arr中索引值是2的元素（第三行）

print(arr[:,2]) #[ 3  6  9 12]  #选取所有行中索引值是2的元素，也就是选取第3列
'''在选取单列时，[]中的逗号前必须得有一个英文冒号，
当冒号前后没有参数时，表示选取所有行，随后再选取指定列。
其实在选取单行时，也可以在[]中输入逗号和冒号，
也就是说之前选取行的代码可以改为print(arr[2,:])'''
print('---')

#选取某些行或某些列的元素
'''如果要选取某些行的元素，指定这些行的索引值区间即可，选取时同样遵循“左闭右开”规则'''
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
'''
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
'''
print(arr[1:3])     #选取索引值1,到 索引值3元素之前的元素，也就是选取第一行与第二行
'''[[4 5 6]
 [7 8 9]]'''

print(arr[:2])  #选取索引值2元素之前的元素
'''[[1 2 3]
 [4 5 6]]'''

print(arr[2:])  #选取索引值2以及2之后的所有元素
'''[[ 7  8  9]
 [10 11 12]]
'''
print('---')

#选取某些列的元素
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
'''
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
'''
print(arr[:,1:3])   #选取每一行中，第2列到第4列之前（第三列）的元素
'''
[[ 2  3]
 [ 5  6]
 [ 8  9]
 [11 12]]'''

print(arr[:,2]) #[ 3  6  9 12]  #选取每一行中，索引值是2的元素

print(arr[:,1:])    #选取每一行中，从索引值1的元素开始，到最后一个元素
'''
[[ 2  3]
 [ 5  6]
 [ 8  9]
 [11 12]]
'''
print('---')
print(arr[0:2,1])   #[2 5]  #选取第索引值从0到索引值2之前的每一行，中的索引值为1的元素

print('---')
#要同时选取行和列的元素，同时给出要选取的行和列的索引值即可
print(arr[0:2,1:3])
#选取从索引值0开始，到索引值2之前的每一行，中的索引值从1开始，索引值3之前的元素
#第一行与第二行中的，第2个到第4个之前的元素
'''
[[2 3]
 [5 6]]'''



#数组的重置与转置
'''
数组的重置是指更改数组的形状，也就是将某个维度的数组转换成另一个维度的数组，例如，将一维数组转换为多维数组，或者将3行4列的 二维数组转换成4行3列的二维数组。

转置是重塑的一种特殊形式，是指将数组的行旋转为列，列旋转为行。
无论是数组重塑还是数组转置，操作前后的数组元素个数都是不会改变的。
'''


print('-----------------------一维数组的重塑-------------------')


'''
Numpy模块中的reshape()函数，可以在不改变数组元素内容和个数的情况下，重塑数组的形状。

在进行数组重塑时，新数组的形状应该与原数组的形状相兼容，比如9个元素的一维数组可以转换成3行3列的数组，但不能转换成2行2列的数组， 即新数组的形状不能导致元素的个数发生改变，否则会报错。

要将一个有12个元素的一维数组转换为二维数组，则二维数组的形状只能是：
1行12列、2行6列、3行4列、4行3列、6行2列、12行1列
'''

'''一维数组的重塑就是将一行或一列的数组转换成多行多列的数组'''

arr=np.array([1,2,3,4,5,6])
a=arr.reshape(2,3)  #将数组转换成2行3列，并将结果赋值给a
print(a)
'''
[[1 2 3]
 [4 5 6]]
'''

a=arr.reshape(3,2)  #将数组转换成3行2列
print(a)
'''
[[1 2]
 [3 4]
 [5 6]]
'''


print('----------多维数组的重塑--------------')
'''reshape()函数除了可以将一维数组转换为多维数组，还可以更改多维数组的形状'''
arr=np.array([[2,2,2,2],[3,3,3,3],[6,6,6,6]])
c=arr.reshape(2,6)  #转换成二行六列并赋值给C
print(c)
'''
[[2 2 2 2 3 3]
 [3 3 6 6 6 6]]'''


print('----------将多维数组转换为一维数组------------------')
arr=np.array([[2,2,2],[3,3,3]])
print(arr.flatten())    #[2 2 2 3 3 3]

print(arr.ravel())  #[2 2 2 3 3 3]



print('--------数组的转置------------------')

'''NumPy模块提供了T属性和transpose()函数两种方法用于数组的转置'''

#T属性
'''T属性的用法很简单，只需要在转置的数组后调用T属性即可,
可以将行转换成列，列转换成行
'''
arr=np.array([[2,2,2],[3,3,3]])
print(arr)
print('---')
print(arr.T)
'''
[[2 3]
 [2 3]
 [2 3]]'''

print('---')

# transpose()函数
'''transpose()函数时通过调换数组的行和列的索引值来转置数组的'''
arr=np.array([[2,2,2],[3,3,3]])
arr1=np.transpose(arr)
print(arr1)
'''
从2行3列转换成3行2列
[[2 3]
 [2 3]
 [2 3]]'''


print('-------------数组的处理--------------------')
'''数组的常见处理操作包括在数组中添加或删除元素、处理数组中的缺失值和重复值、对数组进行拼接和拆分等'''

print('---------添加数组元素----------')
'''使用NumPy模块中的append()函数和insert()函数可以方便地在数组中添加元素'''

print('-------append()函数---------')
#append()函数可以在数组的末尾添加元素
arr=np.array([[2,2,2],[3,3,3]])
arr1=np.append(arr,[[6,6,6]])
print(arr1) #[2 2 2 3 3 3 6 6 6]
#通过append()函数在数组的末尾添加元素后，二维数组变成了一维数组

'''想要使用append()函数往数组中添加元素，又不想改变数组的维度，可以在append()函数中加入一个axis=0的参数,
我们可以简单地理解为，元素会添加在数组的行方向上，
也就是说，数组的行数会增加，但列数不变'''
arr2=np.append(arr,[[6,6,6]],axis=0)
print(arr2)
'''
[[2 2 2]
 [3 3 3]
 [6 6 6]]'''

print('---')
'''axis参数也可以设置为1，表示元素会添加在数组的列方向上，
也就是说，数组的列数会增加，但行数不变。
添加的列数要与原数组的列数相契合，原数组有2列，那么添加1列就会报错'''
arr3=np.append(arr,[[6,6,6],[9,9,9]],axis=1)
print(arr3)
'''[[2 2 2 6 6 6]
 [3 3 3 9 9 9]]'''
#数组从2行3列变为2行6列，数组的维度和行数没有变化，但列数和元素个数却增加了


'''
append()函数的用法
append(arr,values,axis=None)
参数          说明
arr         要添加元素的数组（必须）
values  要添加进数组的数组元素(必须)
axis    省略该参数时，默认为None，表示在数组的末尾添加元素，但数组会转换成一个而一位数组（返回一个一维数组）；当axis值为0，表示在行方向上添加元素，值为1则表示在列方向上添加元素
'''

print('---------insert()函数--------')
'''insert函数表示在数组的指定位置插入元素'''
arr=np.array([[2,2,2],[3,3,3]])
arr1=np.insert(arr,1,[6,6],axis=None) #在索引值为1的位置插入指定元素，且转换成了一维数组
print(arr1) #[2 6 6 2 2 3 3 3]
'''与append()函数一样，insert()函数在插入元素后，默认也会将它转换为一维数组，
想要不改变数组的维度，同样也需要axis参数
axis为0，表示在行方向的指定位置插入元素，也就是说行数会增加但列数不变,注意如果每行有几个元素（列），添加的行中也得有几个元素（列），否则会报错
axis为1，表示在列方向上的指定位置插入元素，列数会增加但行数不会改变,注意原数组有几行，那么添加的数组也只能有几个元素，比如原数组有2行，那么添加的数组也只能有2个元素，要是往一个只有2行的数组，在axis=1的情况下，往3行里插入元素，就会报错'''

arr2=np.insert(arr,1,[6,6,6],axis=0)
print(arr2)
'''
[[2 2 2]
 [6 6 6]
 [3 3 3]]'''
print('---')
arr3=np.insert(arr,1,[[6,6]],axis=1)
print(arr3)
'''
[[2 6 2 2]
 [3 6 3 3]]'''
'''insert()函数的参数说明
参数          说明
arr         需要插入元素的数组（必须）
obj         数组的索引值，即需要在哪个位置插入元素（必须）
values      需要插入的元素（必须）
axis        默认为None,当省略该参数时，会将数组先展开为一维数组，然后在一维数组的指定位置插入元素；当值为0时，表示在行方向的指定位置插入元素，当值为1时，表示在列方向的指定位置插入元素
'''

print('--------删除数组元素-----------------')
'''删除数组元素需要用到NumPy模块中的delete()函数
如果没填写axis值，则默认先将数组转换为一维数组，再删除指定索引值的元素
axis值为0，则删除指定索引值的行，axis值为1，则删除指定索引值的列
'''
arr=np.array([[1,2,3],[4,5,6]])

arr1=np.delete(arr,2)   #转换为一维数组并删除索引值为2的元素
print(arr1) #[1 2 4 5 6]

print('---')

arr2=np.delete(arr,1,axis=0)    #axis值为0，删除索引值为1的行（第二行）
print(arr2) #[[1 2 3]]

print('---')
arr3=np.delete(arr,0,axis=1)    #删除索引值为1的列
print(arr3)
'''
[[2 3]
 [5 6]]'''


print('---------处理数组的缺失值------------')
'''数组的缺失值处理可分两步进行，先找到缺失值的位置，然后用指定的值填充
NumPy模块中的isnan()函数可以标记数组中缺失值的位置'''
arr=np.array([0,np.nan,2])  #np.nan表示缺失值
print(arr)  #[ 0. nan  2.]  #输出含有缺失值的数组arr
print(np.isnan(arr))    #[False  True False]
#用isnan()函数标记缺失值的位置，是缺失值则标记True,没有缺失值则标记False

'''找到缺失值后，可以用isnan()函数对缺失值进行填充'''
arr[np.isnan(arr)]=1    #对arr数组有缺失值的位置填充数字1
print(arr)  #[0. 1. 2.]


print('--------处理数组的重复值---------')
'''使用NumPy模块的unique()函数即可处理重复值，
该函数除了会去除数组中的重复元素，还会将去重后的数组元素从小到大排列'''
arr=np.array([1,1,0,0,2])
arr1=np.unique(arr) #调用unique()函数对数组去重处理
print(arr1) #[0 1 2]
print('---')
arr1,arr2=np.unique(arr,return_counts=True) #return_counts=True用于查看去重后数组中的元素在原数组中出现的次数
print(arr1) #[0 1 2]    #去重后并按照从小到大排列的效果，
print(arr2) #[2 2 1]    #去重之后的数组中的每个元素，在原数组中出现的次数，比如0在原数组中出现2次就显示2

print('---------拼接数组----------------')
'''数组的拼接是指将多个数组合并为一个数组，可以使用NumPy模块中的concatenate()、hstack()、vstack()函数实现，
需要注意的事待合并的几个数组的维度必须相同，
即一维数组智能与一维数组合并，二维数组智能与二维数组合并。
如果是一维数组之间的合并，那么数组的形状可以不一样，
如果是多维数组之间的合并，那数组的形状则必须要相同，也就是数组之间的行数与列数保持一致'''

#concatenate()函数
'''concatenate()函数一次能合并多个数组，是数组拼接最常用的方法,
axis参数用于指定数组拼接的方向，

省略axis参数或axis值设为0，表示在列的方向上拼接，
在列方向上拼接后的数组行数，是原先多个数组的行数之和，而列数不会改变，
相当于将第二个数组直接追加到第一个数组之后，然后生成一个新的数组？

axis值为1表示在行的方向上拼接，也就是说新的合成对象的内容，第一行是将原来的第一个数组的第一行与第二个数组的第一行合并来的，以此类推
在行方向上拼接后的数组行数不会改变，而列数是原先多个数组的列数之和'''
arr1=np.array([[1,1,1],[2,2,2]])
arr2=np.array([[6,6,6],[7,7,7]])

arr3=np.concatenate((arr1,arr2),axis=0)
print(arr3)
'''
[[1 1 1]
 [2 2 2]
 [6 6 6]
 [7 7 7]]'''
print('---')
arr6=np.concatenate((arr1,arr2),axis=1)
print(arr6)
'''
[[1 1 1 6 6 6]
 [2 2 2 7 7 7]]'''



print('-------hstack()函数和vstack()函数-------------')
'''
hstack()函数能以水平堆叠的方式拼接数组，其效果相当于concatenate()函数在行方向上拼接数组；
vstack()函数能以垂直堆叠的方式拼接数组，其效果相当于concatenate()函数在列方向上拼接数组'''

arr1=np.array([[1,1,1],[2,2,2]])
arr2=np.array([[3,3,3],[6,6,6]])


print('---')
hhh=np.hstack((arr1,arr2))
print(hhh)
'''
[[1 1 1 3 3 3]
 [2 2 2 6 6 6]]'''
print('---')
arr1=np.array([[1,1,1],[2,2,2]])
arr2=np.array([[3,3,3],[6,6,6]])
vvv=np.vstack((arr1,arr2))
print(vvv)
'''
[[1 1 1]
 [2 2 2]
 [3 3 3]
 [6 6 6]]'''




print('-----------拆分数组--------------')
'''数组的拆分就是将一个数组分隔成多个数组，可以使用NumPy模块中的split()、hsplit()以及vsplit()函数'''


'''split函数可以按指定的份数将一个数组均分为多个数组，既可以将数组平均地拆分成指定的份数，
也可以按照指定的位置来拆分,如果按照指定的位置来拆分，需要在[]填入若干个索引值，在索引值之前的元素将被拆为一组，然后剩下所有的再合并成一组'''

arr=np.array([1,2,3,4,5,6,7,8,9,0,11,22])
arr1=np.split(arr,2)    #将一维数组拆分成2个大小相等的 一维数组
print(arr1) #[array([1, 2, 3, 4, 5, 6]), array([ 7,  8,  9,  0, 11, 22])]

print('---')
arr=np.array([0,1,2,3,4,5,6,7,8,9,11,22])
arr3=np.split(arr,[2,6]) #表示在arr数组的索引值2（第3个元素）与索引值6的元素之间进行拆分
print(arr3) #[array([0, 1]), array([2, 3, 4, 5]), array([ 6,  7,  8,  9, 11, 22])]
print('---')
arr6=np.split(arr,[2,7,9])   #索引值2之前的元素拆为一组、索引值7之前的拆为一组、索引值9之前的拆为一组，剩下的拆为一组
print(arr6) #[array([0, 1]), array([2, 3, 4, 5, 6]), array([7, 8]), array([ 9, 11, 22])]


print('---------hsplit()和vsplit()函数------------------')
'''hsplit()函数能将一个数组横向拆分成多个数组，
vsplit()函数能将一个数组纵向拆分成多个数组'''


arr1=np.array([[2,2,3],[3,3,3],[6,6,6],[7,7,7]])
arr2=np.hsplit(arr,2)   #横向拆分成2个数组
print(arr2) #[array([0, 1, 2, 3, 4, 5]), array([ 6,  7,  8,  9, 11, 22])]

print('---')
arr3=np.vsplit(arr1,2)
print(arr3)
'''
[array([[2, 2, 3],
       [3, 3, 3]]), array([[6, 6, 6],
       [7, 7, 7]])]'''



print('---------------数组的运算---------------------')
'''NumPy模块的优势不仅在于支持多个维度数据的存储和展示，它还能很好的支持数组的数学运算，如数组之间的四则运算和数组元素的统计运算'''


print('--------数组之间的四则运算-----------------')
'''对于多个形状一致的数组，我们可以直接对它们进行加减乘除等运算，
运算结果是一个由对应位置上的元素分别进行四则运算后的数组'''
arr1=np.array([[2,2,2],[3,3,3]])
arr2=np.array([[3,3,3],[6,6,6]])
arr3=arr1+arr2
print(arr3)
'''[[5 5 5]
 [9 9 9]]'''
print('---')
arr6=arr1*arr2
print(arr6)
'''
[[ 6  6  6]
 [18 18 18]]'''
#以上使用了加法和乘法运算，同样的还可以使用减法和除法运算
print('---')
#除了可以在多个数组之间进行四则运算，还可以对一个数组和一个数值进行四则运算
arr=np.array([[2,2,2],[3,3,3]])
arr2=arr+7
print(arr2)
'''
[[ 9  9  9]
 [10 10 10]]'''
print('---')
arr3=arr*10
print(arr3)
'''
[[20 20 20]
 [30 30 30]]
'''


print('---------数组元素的统计运算---------------')
'''使用NumPy模块中的一些函数可以对数组元素进行统计运算，比如求和、求平均值、求最大值和最小值等'''

print('--------求和-----------')
'''sum()函数用于求和，它除了能对整个数组的所有元素求和，它除了能对整个数组的所有元素求和，还能对数组的每一行或每一列元素分别求和,
不设置参数表示对整个数组的所有元素进行求和’
axis值为0表示每一列元素分别求和，也就是行与行之间对应位置的值相加，生成新的一行；
axis值为1表示每行各自求和，再把每行的和放在一起生成新的数组'''
arr=np.array([[2,2,6],[3,3,3]])
arr1=arr.sum()
print(arr1) #19

arr2=arr.sum(axis=0)
print(arr2) #[5 5 9]

arr3=arr.sum(axis=1)
print(arr3) #[10  9]

print('-----求平均值-----------')
'''mean()函数用于求平均值，它除了能对数组的所有元素求平均值，还能对数组的每一行或每一列元素分别求平均值，参数值用法与sum()函数一致'''
arr=np.array([[2,2,2],[3,3,3]])
arr1=arr.mean()
print(arr1) #2.5
print(arr.mean(axis=0)) #[2.5 2.5 2.5]
print(arr.mean(axis=1)) #[2. 3.]


print('----------求最值------------------')
'''max()函数和min()函数分别用于求数组元素的最大值和最小值。
与sum()函数和mean()函数类似，max()函数和min()函数也能通过设置参数来指定求最值的方式：
如果不设置参数，表示在整个数组范围内寻找最值；
axis值为0表示对数组的每一列元素分别求最大值；
axis值为1表示取每一行的最值，生成新的数组'''
arr=np.array([[0,9,3],[7,8,2]])
print(arr.max())    #9
print(arr.max(axis=0))  #[7 9 3]    #寻找每一列中的最大值，合成新的数组
print(arr.max(axis=1))  #[9 8]  #取每一行中各自的最大值，生成新的数组