Numpy数值计算基础【Python数据分析与应用】

Numpy的数组对象ndarray

由于python的array模块不支持多维，也没有各种运算函数，因此不适合做数值运算

Numpy提供了一种存储单一数据类型的多维数组-ndarray

Numpy提供了两种基本的对象：ndarray(N-dimensional Array Object)和ufunc(Universal Function Object)

ndarray(下文统一称为数组)是存储单一数据类型的多维数组

ufunc则是能够对数组进行处理的函数 |

创建数组对象

#数组属性
'''
ndim  维数 
shape 数组的尺寸，(n,m) n行m列的矩阵
size 数组的元素总数 
dtype 数组中元素的类型 
itemsize  数组的属性值为8
'''
​
​

'\nndim  维数 \nshape 数组的尺寸，(n,m) n行m列的矩阵\nsize 数组的元素总数 \ndtype 数组中元素的类型 \nitemsize  数组的属性值为8\n'

#数组创建  可以创建一维或多维数组
'''
numpy.array(object,dtype=None,copy=True,order='K',subok=False,ndmin=0)
object 接收array    无默认
dtype  接收data-type,表示数组所需的数据类型    默认为None 
ndmin  接收int 指定生成数组应该具有的最小维数  默认为None 
​
'''
import numpy as np 
#创建一维数组
arr1=np.array([1,2,3,4])
arr1
​

array([1, 2, 3, 4])

#创建二维数组
arr2=np.array([[1,2,3,4],[5,6,7,8],[7,8,9,10]])
arr2

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 7,  8,  9, 10]])

#查看属性
#查看数组结构
print(arr2.shape)#(3,4) 3行4列 第0轴的长度为3（即行数），第1轴的长度为4（即列数） 
#查看数组类型
print(arr2.dtype)
#查看数组元素个数 
print(arr2.size)
#查看数组每个元素大小
print(arr2.itemsize)

(3, 4)
int32
12
4

#重新设置数组的shape属性 
​
arr2.shape=4,3
print(arr2)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  7]
 [ 8  9 10]]

#用来创建数组的函数
##arange函数 指定开始值，终值和步长来创建一维数组，数组中不含终值 
print(np.arange(0,1,0.1))
##linspace指定开始值、终值和元素个数来创建一维数组，默认设置包含终值 
print(np.linspace(0,1,12)) 
##logspace 和linespace 创建的为等比数列 
print(np.logspace(0,2,10))#生成开始值为10的0次方 终值为10的2次方，共10个元素的等比数列
​

[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
[0.         0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
 0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1.        ]
[  1.           1.66810054   2.7825594    4.64158883   7.74263683
  12.91549665  21.5443469   35.93813664  59.94842503 100.        ]

#用来创建特殊数组的函数
##使用zeros函数创建值全部为0的数组  
print(np.zeros((2,3)))
##eye函数用来生成主对角线上的元素为1，其他的元素为0的数组，类似于单位矩阵
print(np.eye(3))
##diag函数创建类似对角的数组，即除对角线以外的其他元素都为0，对角线上的元素可以是0或其他值 
print(np.diag([1,2,3,4]))
##ones函数用来创建元素全部为1的数组，即创建的数组元素全部填充为1
print(np.ones((5,3)))

[[0. 0. 0.]
 [0. 0. 0.]]
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
[[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

#数组数据类型
'''
bool   布尔  
int64   整型 
float/float64  (float 默认就是float64 )  浮点型 
str_   字符串型 
complex 复数 
'''
#创建数据类型  使用能存储40个字符的字符串记录商品名称， 64位的整型存储库存数量，64位的浮点数记录价格  
df=np.dtype([('name',np.str_,40),('numitems',np.int64),('price',np.float64)])
print(df)
#查看数据类型 
print(df['name'])
print(np.dtype(df['name']))
​
#自定义数组数据
data=np.array([("tomatoes",42,12.4),("cabbages",13,1.72)],dtype=df)
print(data)
​

[('name', '<U40'), ('numitems', '<i8'), ('price', '<f8')]
<U40
<U40

array([('tomatoes', 42, 12.4 ), ('cabbages', 13,  1.72)],
      dtype=[('name', '<U40'), ('numitems', '<i8'), ('price', '<f8')])

#生成随机数
import numpy as np 
#random函数是生成随机数最常见的方法之一
print(np.random.random(10))
#rand函数可以生成服从均匀分布的随机数 
print(np.random.rand(10,5))
#randn函数可以生成服从正态分布的随机数 
print(np.random.randn(10,5))
#randint函数可以生成给定上下限范围的随机数 
#numpy.random.randint(low,high=None,size=None,dtype='1')
#low最小值，high 最大值  size 为数组的shape
print(np.random.randint(2,10,size=[2,5]))
'''
random模块的常用随机数生成函数 
permutation 返回一个序列随机排列或返回一个随机排列的范围 
Shuffle对一个序列进行随机排列 
binomial 产生二项分布的随机数 
normal产生正态（高斯）分布的随机数 
beta 产生beta分布的随机数 
chisquare 产生卡方分布的随机数 
gamma 产生gamma分布的随机数 
uniform 产生在[0,1]中均匀分布的随机数 
'''
​

[0.14553047 0.42440197 0.18720082 0.42488281 0.22799272 0.0949619
 0.40933559 0.22641412 0.80222171 0.04695276]
[[0.27661693 0.74169349 0.02639073 0.48047856 0.57670161]
 [0.8336217  0.06490751 0.20173426 0.20773873 0.0930375 ]
 [0.59237395 0.85766368 0.73633534 0.41672542 0.04855078]
 [0.35309543 0.88487531 0.19361593 0.13508803 0.8395503 ]
 [0.24154251 0.37548275 0.15784558 0.1432737  0.6453161 ]
 [0.49607272 0.43249312 0.75310895 0.06310683 0.35480952]
 [0.96050402 0.09264279 0.95049958 0.36783218 0.31972151]
 [0.07554429 0.02951368 0.03057689 0.62389515 0.40173791]
 [0.43170203 0.58528169 0.74470878 0.31715637 0.02361943]
 [0.57252887 0.16402313 0.94129609 0.15931488 0.1653825 ]]
[[ 8.70059973e-01  1.63722654e-01  4.90575927e-01  7.87371837e-01
  -5.82085696e-01]
 [ 1.23669515e-01 -6.41531128e-04 -4.54106645e-01 -1.79294389e-02
   1.30252638e+00]
 [ 7.57762692e-01 -1.38515147e-01 -4.40512943e-01  8.47376755e-01
  -1.10943474e+00]
 [ 9.26310783e-01  4.95058222e-01 -1.29911327e+00  1.55495632e+00
   4.89854493e-01]
 [-5.51273989e-01 -1.60706040e+00  2.19479324e-01 -1.49171712e+00
   1.83037726e-01]
 [ 1.62365807e+00  1.61390880e+00 -1.00333142e-01 -3.35683449e-01
  -3.17607181e-01]
 [ 5.52951244e-01  3.23085637e-01  1.46736256e+00 -1.26411800e+00
  -1.52071141e+00]
 [-6.57205093e-01 -9.10929723e-01 -1.16703877e+00  5.22122509e-01
   4.23796817e-01]
 [-2.02227662e-01 -1.46735176e+00  1.27836364e+00  3.50599660e-01
   7.38739025e-02]
 [ 2.31964367e-01  9.90174779e-01 -1.13366584e+00 -1.92384424e-01
  -3.83024553e-01]]
[[7 6 3 6 5]
 [3 5 7 4 6]]

'\nrandom模块的常用随机数生成函数 \npermutation 返回一个序列随机排列或返回一个随机排列的范围 \nShuffle对一个序列进行随机排列 \nbinomial 产生二项分布的随机数 \nnormal产生正态（高斯）分布的随机数 \nbeta 产生beta分布的随机数 \nchisquare 产生卡方分布的随机数 \ngamma 产生gamma分布的随机数 \nuniform 产生在[0,1]中均匀分布的随机数 \n'

#通过索引访问数组 
#一维数组的索引,与list中的索引方法一致
arr=np.arange(10)
print(arr)
print(arr[5])#用整数作为下标可以获取数组中的某个元素
#用范围作为下标获取数组的一个切片，包括arr[3],不包括arr[5]
print(arr[3:5])
#省略开始下标，表示从arr[0]开始 
print(arr[:5])
#下标可以使用负数，-1表示从数组最后往前数的第一个元素
print(arr[-1])
#利用下标修改元素的值
arr[3:5]=100,101
print(arr)
#范围中的第三个参数表示步长，2表示隔一个元素取一个元素 
print(arr[1:-1:2])
#步长为负数时，开始下标必须大于结束下标 
​
print(arr[5:1:-2])

[0 1 2 3 4 5 6 7 8 9]
5
[3 4]
[0 1 2 3 4]
9
[  0   1   2 100 101   5   6   7   8   9]
[  1 100   5   7]
[  5 100]

#多维数组的索引
#使用索引访问多维数组
'''多维数组的每一个维度都有一个索引，各个维度的索引之间用逗号隔开'''
arr=np.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]])
print(arr)
#索引第0行中第3，4列的数据
print(arr[0,3:5])
#索引第2和第3行中第3~5列的元素 
print(arr[1:,2:])
#索引第2列的元素 
print(arr[:,2])
​
#使用整数函数访问多维数组 
#从两行序列的对应位置取出两个整数来组成下标 arr[0,1],arr[1,2],arr[2,3]
print(arr[(0,1,2),(1,2,3)])
#索引第2、3行中第0、2、3列的元素 
print(arr[1:,(0,2,3)])
#布尔值索引访问多维数组 
mask=np.array([1,0,1],dtype=np.bool)
#mask是个布尔数组，它索引第1，3行中第2列的元素 
print(arr[mask,2])

[[ 1  2  3  4  5]
 [ 4  5  6  7  8]
 [ 7  8  9 10 11]]
[4 5]
[[ 6  7  8]
 [ 9 10 11]]
[3 6 9]
[ 2  6 10]
[[ 4  6  7]
 [ 7  9 10]]
[3 9]

import numpy as np
#变换数组的形态
#reshape改变数组的形状，通常不会改变原始数据的值，
#如果指定的维度和数组的元素数目不吻合，则函数抛出异常 
arr=np.arange(12)
print(arr)
#设置数组的形状
print(arr.reshape(3,4))
#查看数组的维度 
print(arr.ndim)
print(arr.reshape(3,4).ndim)

#ravel展平数组 （横向）
arr=np.arange(12).reshape(3,4)
print(arr)
print(arr.ravel())
#flatten函数展平数组（纵向、横向都可以实现）
print(arr.flatten())#横向
print(arr.flatten('F')) #纵向

[ 0  1  2  3  4  5  6  7  8  9 10 11]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
1
2
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[ 0  1  2  3  4  5  6  7  8  9 10 11]
[ 0  1  2  3  4  5  6  7  8  9 10 11]
[ 0  4  8  1  5  9  2  6 10  3  7 11]

#函数完成数组间的组合
#hstack函数实现横向组合，vstack函数实现纵向组合，concatenate函数完成数组间横向或纵向的组合
arr1=np.arange(12).reshape(3,4)
​
arr2=arr1*3
print(arr1)
print(arr2)
#print(np.hstack((arr1,arr2))) #横向组合
​
#print(np.vstack((arr1,arr2)))#纵向组合
print(np.concatenate((arr1,arr2),axis=1))#横向
​
print(np.concatenate((arr1,arr2),axis=0))#纵向

[[ 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]]
[[ 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,vsplit,split函数可以将数组分割成相同大小的子数组，也可以指定原数组中需要分割的位置 
arr=np.arange(16).reshape(4,4)
print(arr)
#print(np.hsplit(arr,4))#横向分割成4个相同大小的子数组
#print(np.vsplit(arr,4)) #纵向分割成4个相同大小的子数组
####print(np.dsplit(arr,4)) 报错 
print(np.split(arr,2,axis=1))#横向
print(np.split(arr,2,axis=0))#纵向

[[ 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]])]
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]

#掌握Numpy矩阵的创建和计算
'''
在Numpy中，矩阵是ndarray的子类。 
Numpy提供了两个基本的对象：一个N维数组对象和一个通用函数对象 
矩阵是继承自Numpy数组对象的二维数组对象 
'''
#创建矩阵 
matr1=np.mat("1 2 3;2 4 5;5 6 7") #使用mat创建，行与行之间使用分号;隔开  不好,行之间的元素使用空格分隔
print(matr1)
matr2=np.matrix([[1,2,3],[2,4,5],[5,6,7]])
print(matr2)
#创建分块矩阵（根据小的矩阵创建大的矩阵）
arr1=np.eye(3)
arr2=arr1*3
print(np.bmat("arr1 arr2"))
print(np.bmat("arr1 arr2;arr1 arr2"))

[[1 2 3]
 [2 4 5]
 [5 6 7]]
[[1 2 3]
 [2 4 5]
 [5 6 7]]
[[1. 0. 0. 3. 0. 0.]
 [0. 1. 0. 0. 3. 0.]
 [0. 0. 1. 0. 0. 3.]]
[[1. 0. 0. 3. 0. 0.]
 [0. 1. 0. 0. 3. 0.]
 [0. 0. 1. 0. 0. 3.]
 [1. 0. 0. 3. 0. 0.]
 [0. 1. 0. 0. 3. 0.]
 [0. 0. 1. 0. 0. 3.]]

#矩阵运算 
import numpy as np 
matr1=np.mat("1 2 3;4 5 6;7 8 9") #创建矩阵
print(matr1)
#矩阵与数相乘
matr2=matr1*3
print(matr2)
#矩阵相加 
#print(matr1+matr2)
#矩阵相减
#print(matr1-matr2)
#矩阵相乘
print(matr1*matr2) #第一行乘以第一列 相加得a11
#矩阵对应元素相乘 
print(np.multiply(matr1,matr2))
​

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[ 3  6  9]
 [12 15 18]
 [21 24 27]]
[[ 90 108 126]
 [198 243 288]
 [306 378 450]]
[[  3  12  27]
 [ 48  75 108]
 [147 192 243]]

#矩阵属性
print(matr1)
#矩阵的转置 
print(matr1.T)
#矩阵的共轭转置（实数的共轭就是其本身）
print(matr1.H)
#逆矩阵
print(matr1.I)
#返回二维数组的视图 
print(matr1.A)

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[1 4 7]
 [2 5 8]
 [3 6 9]]
[[1 4 7]
 [2 5 8]
 [3 6 9]]
[[ 3.15251974e+15 -6.30503948e+15  3.15251974e+15]
 [-6.30503948e+15  1.26100790e+16 -6.30503948e+15]
 [ 3.15251974e+15 -6.30503948e+15  3.15251974e+15]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

#Numpy另一个基本对象：通用函数_____ufunc函数 能够对数组中的所有元素进行操作的函数 
#ufunc函数针对数组进行操作，并且都以Numpy数组作为输出 
'''
常用的ufunc函数运算 ：四则运算 比较运算 逻辑运算等 
'''
#数组间四则运算表示对每个数组中的元素分别进行四则运算，所以进行四则运算的两个数组的形状必须相同 
x=np.array([1,2,3])
y=np.array([4,5,6])
#数组相加
print(x+y)
#数组相减 
print(x-y)
#数组相乘 
print(x*y)
#数组相除 
print(x/y)
#数组幂运算 
print(x**y)

[5 7 9]
[-3 -3 -3]
[ 4 10 18]
[0.25 0.4  0.5 ]
[  1  32 729]

#数组的比较运算 > <  ==  >=  <= !=   np.all()表示逻辑and  np.any()表示逻辑or
print(x)#[1 2 3]
print(y)#[4 5 6]
print(x<y)
print(x>y)
print(x==y)
print(x!=y)
print(np.all(x==y))
print(np.any(x==y))

[1 2 3]
[4 5 6]
[ True  True  True]
[False False False]
[False False False]
[ True  True  True]
False
False

#ufunc函数的广播机制
'''
广播（Broadcasting）是指不同形状的数组之间执行算数运算的方式，广播机制的4个原则：
1.让所有的输入数组 向其中shape最长的数组看齐，shape中不足的部分通过在前面加1补齐 
2.输出数组的shape是输入数组shape的各个轴上的最大值 
3.如果 输入数组的某个轴 和 输出数组大的对应轴的长度相同或者其长度为1，则这个数组能够用来计算，否则出错 
4.当输入数组的某个轴的长度为1时，沿着此轴运算时使用此轴上的第一组值 
'''
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
#print(arr1)
arr2=np.array([2])  #规则3 np.array([1,2,3]) 或者np.array([1])
#print(arr2)
#print(arr1+arr2)
#二维数组的广播机制 
arr3=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print(arr3)
arr4=np.array([1,2,3,4]).reshape((4,1))
print(arr4)
​
arr5=np.array([1,2,3]).reshape((1,3))
print(arr5)
print(arr3+arr4)
print(arr3-arr5)

[[0 0 0]
 [1 1 1]
 [2 2 2]
 [3 3 3]]
[[1]
 [2]
 [3]
 [4]]
[[1 2 3]]
[[1 1 1]
 [3 3 3]
 [5 5 5]
 [7 7 7]]
[[-1 -2 -3]
 [ 0 -1 -2]
 [ 1  0 -1]
 [ 2  1  0]]

利用Numpy进行统计分析

## 读写文件 
'''
文件读写 ：二进制的文件读写 文件列表形式的数据读写 
'''
#save函数以二进制的格式保存数据，load函数从二进制的文件中读取数据 
#np.save(file,arr,allow_pickle=True,fix_imports=True) 
'''
参数file为要保存的文件的名称，需要指定文件保存的路径，如果未设置，则保存到默认路径下面 
参数 arr 为需要保存的数组 
'''
import numpy as np #导入Numpy库 
arr=np.arange(100).reshape(10,10) #创建一个数组 
#np.save("./save_arr",arr) #保存数组  文件的拓展名为.npy
print(arr)
​
arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.arange(0,1,0.1)
np.savez("./save_arr1",arr1,arr2)#将多个数组保存到一个文件中，可以使用savez函数

[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]
 [30 31 32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47 48 49]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]
 [80 81 82 83 84 85 86 87 88 89]
 [90 91 92 93 94 95 96 97 98 99]]

#需要读取二进制文件的时候可以使用load函数，用文件名作为参数
loaded_data=np.load("./save_arr.npy")#读取含有单个数组的文件 
print(loaded_data)

[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]
 [30 31 32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47 48 49]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]
 [80 81 82 83 84 85 86 87 88 89]
 [90 91 92 93 94 95 96 97 98 99]]

#读取含有多个数组的文件 
loaded_data1=np.load("./save_arr1.npz")
print(loaded_data1["arr_0"])
print(loaded_data1["arr_1"])

[[1 2 3]
 [4 5 6]]
[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

#文本格式的数据
'''
使用savetxt函数， loadtxt函数， genfromtxt函数 执行对文本格式数据的读取任务  
savetxt函数可将数组写到以某种分隔符隔开的文本文件中 
np.savetxt(fname,x,fmt='%.18e',delimiter=' ',newline='\n',header='',footer='',comments='# ')
第一个参数是文件名“file”,第二个参数X为数组数据，第4个参数是分隔符
'''
arr=np.arange(0,12,0.5).reshape(4,-1)
print(arr)
#fmt="%d"表示保存的为整数
np.savetxt("./arr.txt",arr,fmt="%d",delimiter=",")
#loadtxt函数执行的是相反的操作，即把文件加载到一个二维数组中
loaded_data=np.loadtxt("./arr.txt",delimiter=",")
print(loaded_data)
#genfromtxt函数和loadtxt函数相似，不过它面向的是结构化数组和缺失数据。
'''
genfromtxt函数 它通常使用的参数有3个，即存放数据的文件名参数"fname",用于分隔的字符参数"delimiter"
和是否含有列标题参数"names"
'''
loaded_data1=np.genfromtxt("./arr.txt",delimiter=",")
print(loaded_data1)

[[ 0.   0.5  1.   1.5  2.   2.5]
 [ 3.   3.5  4.   4.5  5.   5.5]
 [ 6.   6.5  7.   7.5  8.   8.5]
 [ 9.   9.5 10.  10.5 11.  11.5]]
[[ 0.  0.  1.  1.  2.  2.]
 [ 3.  3.  4.  4.  5.  5.]
 [ 6.  6.  7.  7.  8.  8.]
 [ 9.  9. 10. 10. 11. 11.]]
[[ 0.  0.  1.  1.  2.  2.]
 [ 3.  3.  4.  4.  5.  5.]
 [ 6.  6.  7.  7.  8.  8.]
 [ 9.  9. 10. 10. 11. 11.]]

#使用函数进行简单的统计分析 
##排序 
'''
直接排序和间接排序 
直接排序指对数值直接进行排序；间接排序是指根据一个或多个键对数据集进行排序 
直接排序用sort函数，间接排序使用argsort函数和lexsort函数 
'''
##sort
'''
sort函数是最常用的排序方法，无返回值。如果目标函数是一个视图，则原始数据将会被修改。
使用sort函数排序时可以指定一个axis参数，使得sort函数可以沿着指定轴对数据集进行排序
'''
np.random.seed(42)#设置随机种子 
arr=np.random.randint(1,10,size=10) #生成随机数组
print(arr)
#直接排序 
arr.sort()
print(arr)
arr=np.random.randint(1,10,size=(3,3))
print(arr)
arr.sort(axis=0)#纵轴 
print(arr)
arr.sort(axis=1)#横轴
print(arr)

[7 4 8 5 7 3 7 8 5 4]
[3 4 4 5 5 7 7 7 8 8]
[[8 8 3]
 [6 5 2]
 [8 6 2]]
[[6 5 2]
 [8 6 2]
 [8 8 3]]
[[2 5 6]
 [2 6 8]
 [3 8 8]]

#使用argsort函数进行排序 
import numpy as np
arr=np.array([2,3,6,8,0,7])
print(arr)
#使用argsort函数，返回值为重新排序值的下标 
print(arr.argsort())
#使用lexsort函数进行排序 
#lexsort函数可以一次性对满足多个键的数组执行间接排序 
a=np.array([3,2,6,4,5])
b=np.array([50,30,40,20,10])
c=np.array([400,300,600,100,200])
print(c)
d=np.lexsort((a,b,c)) 
#lexsort函数只接收一个参数 即（a,b,c）
#多个键值排序时是按照最后一个传入数据计算的
print(list(zip(a[d],b[d],c[d])))

[2 3 6 8 0 7]
[4 0 1 2 5 3]
[400 300 600 100 200]
[(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]

##去重与数据重复 
#在Numpy中，可以通过unique函数找出数组中的唯一值并返回已排序的结果 
names=np.array(["小明","小黄","小花","小明","小花","小兰"])

print(np.unique(names)) #去重并排序
print(sorted(set(names)))

##数据重复，即需要把一个数据重复若干次。在numpy中主要使用title函数和repeat函数实现数据重复

#numpy.tile(A,reps)  "A"指定重复的数组，"reps"指定重复的次数  
arr=np.arange(5)
print(arr)
print(np.tile(arr,3))
#numpy.repeat(a,repeats,axis=None)  a需要重复的数组元素 repeats重复次数  axis指定沿着哪个轴进行重复 
np.random.seed(42)#设置随机种子 
arr=np.random.randint(0,10,size=(3,3))
print(arr)
print(np.repeat(arr,2,axis=0))#按行进行元素重复 
print(np.repeat(arr,2,axis=1))
#tile和repeat的区别：tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作

['小兰' '小明' '小花' '小黄']
['小兰', '小明', '小花', '小黄']
[0 1 2 3 4]
[0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
[[6 3 7]
 [4 6 9]
 [2 6 7]]
[[6 3 7]
 [6 3 7]
 [4 6 9]
 [4 6 9]
 [2 6 7]
 [2 6 7]]
[[6 6 3 3 7 7]
 [4 4 6 6 9 9]
 [2 2 6 6 7 7]]

#常用的数据统计函数 sum  mean  std 标准差  var 方差  min  max
'''当axis参数为0时，表示沿着纵轴进行计算 当axis参数为1时，表示沿着横轴进行计算 '''
arr=np.arange(20).reshape(4,5)
print(arr)
print(np.sum(arr))#计算数组的和
print(arr.sum(axis=0))#沿着纵轴求和
print(arr.sum(axis=1))#沿着横轴求和
#以上为聚合操作，除此之外，可以使用累加或者累积函数进行计算
#cumsum累计和 cumprod 累计积

arr=np.arange(2,10)
print(arr)
print(np.cumsum(arr))
print(np.cumprod(arr))

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
190
[30 34 38 42 46]
[10 35 60 85]
[2 3 4 5 6 7 8 9]
[ 2  5  9 14 20 27 35 44]
[     2      6     24    120    720   5040  40320 362880]