numpy库

import numpy as np

a=[[0,1,2,3,4],
   [9,8,7,6,5]]
b=[[0 1 2 3 4]
   [9 8 7 6 5]]
a是我们常见的逗号分隔数据的列表，b就是一个np类型
b != a
b=np.array(a)

import numpy as np

a=[[0,1,2,3,4],
   [9,8,7,6,5]] 
b=np.array(a)  #生成一个ndarray数组，这个数组由空格分隔
'''
[[0 1 2 3 4]
 [9 8 7 6 5]]
'''

a.tolist() 将数组向列表转换

import numpy as np

a=[[0,1,2,3,4],
   [9,8,7,6,5]] 
b=np.array(a)  

print(b.tolist())
'''
[[0, 1, 2, 3, 4], [9, 8, 7, 6, 5]]
'''

import numpy as np

a=np.full((2,3,4),25,dtype=np.int32)

print(a)
'''
[[[25 25 25 25]
  [25 25 25 25]
  [25 25 25 25]]

 [[25 25 25 25]
  [25 25 25 25]
  [25 25 25 25]]]
'''

print(a.tolist())
'''
[[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]], 
 [[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]]]
'''

1. ndarray数组的创建方法

import numpy as np
x=np.array([0,1,2,3])
print(x)
x=np.array([(0,1),[2,3],(0.3,0.4)])
print(x)

输出结果如下：
[0 1 2 3]

[[0.  1. ]
 [2.  3. ]
 [0.3 0.4]]

2、使用numpy中函数创建ndarray数组

np.arange(n)：类似range函数，返回ndarray类型，元素从0到n-1
np.eye(n)：创建一个正方的n*n单位矩阵，对角线为1，其余为0

np.ones(shape)：根据shape生成一个全1数组
np.zeros(shape)：根据shape生成一个全0 数组
np.full(shape,number)：生成一个每个元素值都是number的数组

np.ones_like(a)：根据数组a的形状生成一个全1数组
np.zeros_like(a)：根据数组a的形状生成一个全0数组
np.full_like(a,number)：根据数组a的形状生产一个元素值都是number的数组

根据以上的方法生成的数组里面的数据可能是浮点型，所以你只需要添加一个dtype=np.int32参数即可变成int型

np.arange(4) 
'''
[0 1 2 3]
'''

np.eye(5)  
'''
[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]
'''

np.ones((2,3,4))  
'''
[[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]

 [[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]
'''

np.ones_like(a)：根据数组a的形状生成一个全1数组
np.zeros_like(a)：根据数组a的形状生成一个全0数组
np.full_like(a,number)：根据数组a的形状生产一个元素值都是number的数组

3、使用numpy中其他函数创建ndarray数组

np.linspace()：根据起止数据等间距地填充数据，形成数组
np.concatenate()：将两个或多个数组合并成一个新的数组

import numpy as np

a=np.linspace(1,10,4)
print(a)

b=np.linspace(1,10,4,endpoint=False)#endpoint=false不显示最后一位数字
print(b)

c=np.concatenate((a,b))
print(c)

输出结果如下：
[ 1.  4.  7. 10.]

[1.   3.25 5.5  7.75]

[ 1.    4.    7.   10.    1.    3.25  5.5   7.75]

2. ndarray数组的变换

1.维度的变换
（1）a.reshape(shape) 不改变元数组，返回新维度的数组

（2）a.resize(shape) 改变元数组，无返回值


（3）关于"a.reshape(-1)"

import numpy as np
c=np.array([[1,2,3],[4,5,6]])
print('两行三列')
print(c.reshape(2,3))
[[1 2 3]
 [4 5 6]]

print('三行两列')
print(c.reshape(3,2))
[[1 2]
 [3 4]
 [5 6]]

print('我也不知道是几行，反正就是1列')
print(c.reshape(-1,1))
[[1]
 [2]
 [3]
 [4]
 [5]
 [6]]

print('我也不知道是几列，反正就是1行')
print(c.reshape(1,-1))
[[1 2 3 4 5 6]]

print('不分行列，就是一串数字')
print(c.reshape(-1))
[1 2 3 4 5 6]

z = np.array([[1, 2, 3, 4],  [5, 6, 7,8],  [9, 10, 11, 12],  [13, 14, 15, 16]])
print(z.reshape(-1)) 
输出：[ 1 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16] 

（4）a.flatten() 对数组降维，变为一维数组，不改变原数组

import numpy as np
z = np.array([[1, 2, 3, 4],  [5, 6, 7,8],  [9, 10, 11, 12],  [13, 14, 15, 16]])
print(z.reshape(-1)) 
print(z.flatten())
print(z.ravel())


'''
输出都是
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
'''

（5）np.ravel()

import numpy as np
z = np.array([[1, 2, 3, 4],  [5, 6, 7,8],  [9, 10, 11, 12],  [13, 14, 15, 16]])
print(z.reshape(-1)) 
print(z.flatten())
print(z.ravel())


'''
输出都是
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
'''

(6)np.vstack()

import numpy as np

a=[1, 2, 3, 11, 22, 33, 44, 55, 66]
print(np.vstack(a))

'''
[[ 1]
 [ 2]
 [ 3]
 [11]
 [22]
 [33]
 [44]
 [55]
 [66]]
'''

import numpy as np

a=np.array([1,2,3])
b=np.array([11,22,33])
c=np.array([44,55,66])
feature1=np.concatenate((a,b,c),axis=0)
feature2=np.vstack(feature1)
print(feature1)
print(feature2)

'''
[ 1  2  3 11 22 33 44 55 66]
[[ 1]
 [ 2]
 [ 3]
 [11]
 [22]
 [33]
 [44]
 [55]
 [66]]
'''

（7）swapaxes(ax1,ax2)将数组n个维度中两个维度进行调换

（8）np的拼接

import numpy as np

a=np.array([1,2,3])
b=np.array([11,22,33])
c=np.array([44,55,66])
feature=np.concatenate((a,b,c),axis=0)
print(feature)
'''[ 1  2  3 11 22 33 44 55 66]
这是一维数组的拼接
'''


a=np.array([[1,2,3],[4,5,6]])
b=np.array([[11,21,31],[7,8,9]])
feature=np.concatenate((a,b),axis=0)
print(feature)
'''
[[ 1  2  3]
 [ 4  5  6]
 [11 21 31]
 [ 7  8  9]]
二维列拼接
'''

a=np.array([[1,2,3],[4,5,6]])
b=np.array([[11,21,31],[7,8,9]])
feature=np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接
print(feature)
'''
[[ 1  2  3 11 21 31]
 [ 4  5  6  7  8  9]]
二维行拼接
'''

（9）set()函数

labels=[0, -1, 0, 1, -1, 1, 0, 1, 2, -1, 1, 0, 1, 1, 3, -1, -1, 3, -1, 1, 1, -1, 1, 3, 4, -1, 1, 1, 2, 0, 2, 2, -1, 0, 1, 0, 0, 0, 1, 3, -1, 0, 1, 1, 0, 0, 2, -1, 1, 3, 1, -1, 3, -1, 3, 0, 1, 1, 2, 3, 3, -1, -1, -1, 0, 1, 2, 1, -1, 3, 1, 1, 2, 3, 0, 1, -1, 2, 0, 0, 3, 2, 0, 1, -1, 1, 3, -1, 4, 2, -1, -1, 0, -1, 3, -1, 0, 2, 1, -1, -1, 2, 1, 1, 2, 0, 2, 1, 1, 3, 3, 0, 1, 2, 0, 1, 0, -1, 1, 1, 3, -1, 2, 1, 3, 1, 1, 1, 2, -1, 5, -1, 1, 3, -1, 0, 1, 0, 0, 1, -1, -1, -1, 2, 2, 0, 1, 1, 3, 0, 0, 0, 1, 4, 4, -1, -1, -1, -1, 4, -1, 4, 4, -1, 4, -1, 1, 2, 2, 3, 0, 1, 0, -1, 1, 0, 0, 1, -1, -1, 0, 2, 1, 0, 2, -1, 1, 1, -1, -1, 0, 1, 1, -1, 3, 1, 1, -1, 1, 1, 0, 0, -1, 0, -1, 0, 0, 2, -1, 1, -1, 1, 0, -1, 2, 1, 3, 1, 1, -1, 1, 0, 0, -1, 0, 0, 3, 2, 0, 0, 5, -1, 3, 2, -1, 5, 4, 4, 4, -1, 5, 5, -1, 4, 0, 4, 4, 4, 5, 4, 4, 5, 5, 0, 5, 4, -1, 4, 5, 5, 5, 1, 5, 5, 0, 5, 4, 4, -1, 4, 4, 5, 4, 0, 5, 4, -1, 0, 5, 5, 5, -1, 4, 5, 5, 5, 5, 4, 4]
labels=np.array(labels)
print(set(labels))
'''
统计出了这个列表里面的包含的元素集合
{0, 1, 2, 3, 4, 5, -1}
'''

n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)  #减去噪声数据-1占的位置
print("Estimate number of clusters:%d"%n_clusters_)#输出蔟的个数
'''Estimate number of clusters:6'''

(10)统计np.array数组里面某一元素的个数

import numpy as np
labels=[0, -1, 0, 1, -1, 1, 0, 1, 2, -1, 1, 0, 1, 1, 3, -1, -1, 3, -1, 1, 1, -1, 1, 3, 4, -1, 1, 1, 2, 0, 2, 2, -1, 0, 1, 0, 0, 0, 1, 3, -1, 0, 1, 1, 0, 0, 2, -1, 1, 3, 1, -1, 3, -1, 3, 0, 1, 1, 2, 3, 3, -1, -1, -1, 0, 1, 2, 1, -1, 3, 1, 1, 2, 3, 0, 1, -1, 2, 0, 0, 3, 2, 0, 1, -1, 1, 3, -1, 4, 2, -1, -1, 0, -1, 3, -1, 0, 2, 1, -1, -1, 2, 1, 1, 2, 0, 2, 1, 1, 3, 3, 0, 1, 2, 0, 1, 0, -1, 1, 1, 3, -1, 2, 1, 3, 1, 1, 1, 2, -1, 5, -1, 1, 3, -1, 0, 1, 0, 0, 1, -1, -1, -1, 2, 2, 0, 1, 1, 3, 0, 0, 0, 1, 4, 4, -1, -1, -1, -1, 4, -1, 4, 4, -1, 4, -1, 1, 2, 2, 3, 0, 1, 0, -1, 1, 0, 0, 1, -1, -1, 0, 2, 1, 0, 2, -1, 1, 1, -1, -1, 0, 1, 1, -1, 3, 1, 1, -1, 1, 1, 0, 0, -1, 0, -1, 0, 0, 2, -1, 1, -1, 1, 0, -1, 2, 1, 3, 1, 1, -1, 1, 0, 0, -1, 0, 0, 3, 2, 0, 0, 5, -1, 3, 2, -1, 5, 4, 4, 4, -1, 5, 5, -1, 4, 0, 4, 4, 4, 5, 4, 4, 5, 5, 0, 5, 4, -1, 4, 5, 5, 5, 1, 5, 5, 0, 5, 4, 4, -1, 4, 4, 5, 4, 0, 5, 4, -1, 0, 5, 5, 5, -1, 4, 5, 5, 5, 5, 4, 4]
labels=np.array(labels)
print(labels)

ratio = len(labels[labels[:]==-1]) / len(labels) # 判定噪声数据（label被打上-1）数据所占的比例
print("Noise ratio:{:.2f}".format(ratio)) #输出噪声数据所占的比例
'''
labels[:]==-1得到的是[False  True False False  True ...]这样的列表
labels[labels[:]==-1]得到的是[-1 -1 -1 -1...]这种所有等于-1的元素集合起来的列表
len(labels[labels[:]==-1])就是求出了在labels里面元素等于-1的个数
'''

总之，在np.array数组里面，有ratio = len(labels[labels[:]==-1]) / len(labels) 这样的用法来统计个数，你必须知道

（11）典型例子

import numpy as np
city=['太原','北京','上海','成都','西安','南京','广州','西宁']
rank=[  2,    0,      0,     1,     1,    1,    0,      2  ] #城市对应的排名
ranks=np.array(rank)
citys=np.array(city)

print(ranks[:]==2)  #[False False False  True  True  True False False]
print('----------------------------------------------------')

num=len( ranks[ranks[:]==2] )   #ranks里面元素等于2的元素的数量（也就是排名第二的城市的数量）
print(num)
print('----------------------------------------------------')

print( citys[ranks[:]==2]  )  #输出排名第二的城市
print('----------------------------------------------------')

print( set(ranks) )
print('----------------------------------------------------')

for i in range( len(set(ranks)) ):
    print('排名第',i,'的城市是：')
    print( citys[ranks[:]==i] )
print('----------------------------------------------------')

2.类型的变换
a.astype(new_type) 改变数组的数据类型，不改变原数组
np.int 表示int 类型，具体表示为哪一种int类型，根据数据的大小。

3. ndarray对象的属性

import  numpy

c=numpy.random.randint(4,10,size=(3,3,4))

print(c.ndim)    # 返回维度（也就是秩）---3
print(c.shape)   #打印(维度，行数，列数)或（行数，列数）---(3, 3, 4)
print(c.size)   #元组里面的元素总和---36
print(c.dtype)   #打印元素类型--------- int32
print(c.itemsize)  #itemsize每个元素占的字节---4

4.数组的索引与切片

切片

切片 a[1:4:2]就是a[起始编号：终止编号：步长]，在a[1:4:2]中获取到的依次是a[1]和a[1+2]

索引

a[1，2，3]就是第1维的第2行第3列（注意存在第0维、第0行、第0列）
a[-1,-2,-3]就是倒数第1维的倒数第2行的倒数第三列（不存在倒数第0维、倒数第0行、倒数第0列）

a[:,1,-3]就是截取所有维度下的第1行倒数第3列
a[:,1:3,:]就是截取所有维度下的第1行第2行下的所有列
a[:,:,::2]就是截取所有维度下的所有行下的步长以2划分得到的列

a[:2,1:]是第0行和第1行（含头不含尾所以没有第2行）的第一列到最后一列（包括最后一列）

import numpy as np
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]
'''
print(a[:2,1:])
'''
[[2 3]
 [5 6]]
'''

已知real_X为
[[    22   1558]
 [    12  40261]
 [    22   1721]
 [    23    351]
 [    16  23564]
 [    23   1162]
 [    22   3540]
 ...
 ]
 
X = real_X[:,0:1]
Y=real_X[:,0]
XX=real_X[:,1:]
YY=real_X[:,1]

'''
X为：
[[22]
 [12]
 [22]
 [23]
 [16]
 [23]
 [22]
 ...
 ]


Y为[22 12 22 23 16 23 22 ....]

XX为

[[  1558]
 [ 40261]
 [  1721]
 [   351]
 [ 23564]
 ...
 ]

YY为[  1558  40261   1721    351  23564 ...]
'''

筛选有用的行

如果
import numpy as np

a=[[0.06824773998019218, 0.9317522600198078], [0.007431585685534259, 0.9925684143144657], [0.05832069801904216, 0.9416793019809578], [0.02456363788335514, 0.9754363621166449], [0.015972037036136255, 0.9840279629638637], [0.0006378256421709638, 0.999362174357829], [0.024103908695498055, 0.975896091304502], [0.06574348000807206, 0.9342565199919279], [0.001247089988504979, 0.998752910011495], [0.9998876180656812, 0.00011238193431883273], [0.999999999998435, 1.5649625474161431e-12], [0.032580407650663834, 0.9674195923493362], [0.006040438955114302, 0.9939595610448857], [0.1292332581924438, 0.8707667418075562], [0.9999999999999933, 6.71087472747175e-15], [0.005167124858166727, 0.9948328751418333], [0.8966987279877104, 0.10330127201228954], [0.020563116634066514, 0.9794368833659335], [0.0003196139537828824, 0.9996803860462171], [0.0176736309431631, 0.9823263690568369], [0.13745352905020158, 0.8625464709497984], [0.056590746628155775, 0.9434092533718442], [0.0002804915614214032, 0.9997195084385786], [0.9999983527174068, 1.647282593243217e-06], [0.0677221051073712, 0.9322778948926288], [0.15345761169616212, 0.8465423883038379], [0.016075321053276137, 0.9839246789467239], [0.02108364793132156, 0.9789163520686784], [0.12468787052478303, 0.875312129475217], [0.12707943990930604, 0.872920560090694], [0.9997993155628417, 0.0002006844371582809], [0.9999847242931277, 1.5275706872340652e-05], [0.0167244562794443, 0.9832755437205557], [0.0010471914137498706, 0.9989528085862501], [0.0016407553851515155, 0.9983592446148485], [0.02175401658294307, 0.9782459834170569], [0.0054261833593199915, 0.99457381664068], [0.9022634574878214, 0.09773654251217861], [0.0005503513243121372, 0.9994496486756879], [0.9993240786851992, 0.0006759213148007624], [0.2597015936628273, 0.7402984063371727], [0.0016991060662702173, 0.9983008939337298], [0.8894044573496374, 0.1105955426503626], [0.9999999999924626, 7.537419164497515e-12], [0.09426164221625777, 0.9057383577837422], [0.018519454865909557, 0.9814805451340904], [0.001734962908491955, 0.998265037091508], [0.7730290484480654, 0.22697095155193459], [0.16306757289135954, 0.8369324271086405], [0.009669002941627203, 0.9903309970583728], [0.9999973080412881, 2.6919587119915377e-06], [0.0011845795642243528, 0.9988154204357756], [0.9999986532944521, 1.3467055478402184e-06], [0.14263798111388937, 0.8573620188861106], [0.9999943196524678, 5.680347532251823e-06], [0.9999999999981656, 1.8344634473246033e-12], [0.981121142037181, 0.018878857962818924], [0.06865092163323405, 0.931349078366766], [0.12023056851309888, 0.8797694314869011], [0.0022048975934682025, 0.9977951024065318], [0.139877761103119, 0.860122238896881], [0.9811456367469089, 0.01885436325309114], [0.008892262788881666, 0.9911077372111183], [0.004638816102628618, 0.9953611838973714], [0.03840089181692807, 0.9615991081830719], [0.9999999999999994, 5.843082649799142e-16], [0.01839080022375672, 0.9816091997762433], [0.9949771240274407, 0.005022875972559326], [0.22936769206838115, 0.7706323079316189], [0.7354409183725052, 0.2645590816274948], [0.9861803433971839, 0.013819656602816154], [0.2729785667128939, 0.7270214332871061], [0.0021232184180380864, 0.9978767815819619], [0.8847776570859435, 0.11522234291405657], [0.0011679712322313351, 0.9988320287677687], [0.7825847112787101, 0.21741528872128996], [0.9999989874784122, 1.0125215877830859e-06], [0.00036718540128866106, 0.9996328145987113], [0.005253555753026107, 0.9947464442469739], [0.4981739697098335, 0.5018260302901665], [0.003941554670213621, 0.9960584453297864], [0.08575864659677934, 0.9142413534032207], [0.0008564214240017742, 0.9991435785759982], [0.0005311371340102067, 0.9994688628659898], [0.9999943202204088, 5.679779591226235e-06], [0.0027845676312813206, 0.9972154323687187], [0.1066942115892725, 0.8933057884107275], [0.9943777136208137, 0.005622286379186281], [0.0002588808577045354, 0.9997411191422955], [0.007875008637663883, 0.9921249913623361], [0.0007974542115928296, 0.9992025457884072], [0.006425885206670867, 0.9935741147933291], [0.05124838307668378, 0.9487516169233162], [0.999999995791739, 4.208260908745235e-09], [0.9999999836295631, 1.637043694803631e-08], [0.9950961203736751, 0.004903879626324851], [0.9999774686030084, 2.2531396991555682e-05], [0.002649991202093527, 0.9973500087979065], [0.004621490317962884, 0.9953785096820371], [0.05398215714461985, 0.9460178428553802], [0.9999996326264566, 3.673735433606294e-07], [0.012632123471857826, 0.9873678765281422], [0.9959108887819157, 0.004089111218084328], [0.0124472975977582, 0.9875527024022418], [0.9955426255562442, 0.004457374443755871], [0.9999998913071046, 1.0869289533202495e-07], [0.0039681934668953645, 0.9960318065331046], [0.9968131904018327, 0.0031868095981672957], [0.9999552570885119, 4.4742911488141684e-05], [0.0018993109474175762, 0.9981006890525824], [0.9999878529277032, 1.2147072296795838e-05], [0.0051198113547635815, 0.9948801886452364], [0.003540645486924676, 0.9964593545130753], [0.07963523941312733, 0.9203647605868727]]
aa=np.array(a) 

那么
result0=aa[ aa[:, 0] > 0.1 ] 就是找出aa里面第0列大于0.1的那些行
result1=result0[ result0[:, 1] > 0.1 ]  就是找出result0里面第1列大于0.1的那些行

上面的输出如下：
print(aa)
'''
[[6.82477400e-02 9.31752260e-01]
 [7.43158569e-03 9.92568414e-01]
 [5.83206980e-02 9.41679302e-01]
 [2.45636379e-02 9.75436362e-01]
 ....
 ]

可以清楚的看到aa是多行两列的数组，
'''
print(aa[:, 0] > 0.1)
'''
[False False False False False ...]
就是找出了第0列大于0.1的那些行,得到的结果是False或True
'''
print(aa[ aa[:, 0] > 0.1 ])
'''
[[9.99887618e-01 1.12381934e-04]
 [1.00000000e+00 1.56496255e-12]
 [1.29233258e-01 8.70766742e-01]
 [1.00000000e+00 6.71087473e-15]
 ...
 ]
就是找出aa里面第0列大于0.1的那些行
'''
print(result0[:, 1] > 0.1)
'''
[False False False False False ...]
就是找出了第1列大于0.1的那些行,得到的结果是False或True
'''
print(result0[ result0[:, 1] > 0.1 ])
'''
[[0.12923326 0.87076674]
 [0.89669873 0.10330127]
 [0.13745353 0.86254647]
 [0.15345761 0.84654239]
 ...
 ]
就是找出result0里面第1列大于0.1的那些行
'''

4. ndarray数组的运算函数

①运算函数（一元函数）

• np.cos(x) 余弦 np.sin(x) 正弦 np.tan(x)正切
• np.abs(x)或 np.fabs(x) 计算数组各元素的绝对值
• np.square(x) 计算数组各元素的平方
• np.sqrt(x) 计算数组各元素的平方根
• np.log(x)是以e为底数！！
• np.log10(x) np.log2(x) 以10底对数，2底对数
• np.exp(x) 计算数组各元素的指数值
• np.ceil(x) np.floor(x) 计算数组各元素的ceiling值或floor值（celling是不超过元素的整数的最大值，floor是超过元素的整数最小值）
• np.rint(x) 计算数组各元素的四舍五入值
• np.modf(x) 将数组各元素的小数和整数部分以两个独立数组形式返回
  
  
  ②运算函数（二元函数）
  
  

5. numpy的随机函数

• 像np.random.rand(shape)就是产生(0,1)范围内的数，所以参数只有shape
• 像np.random.randn(shape)就是产生标准正态分布（范围也是给定的），所以参数也是只有shape
• 像其他的：np.random.randint(0, 3, size = (2, 3))和np.random.uniform(0, 3, size = (2, 3)) 和np.random.normal(0.1 , 2.0 , size = (2, 3)) 都是优先配置那些属性参数，然后再用"size=(3,2)"这样的语句控制形状shape
• np.random.uniform(low, high, size =)是什么意思？就是说对于low、high是不需要单独弄个括号的，而size就需要。如：np.random.uniform(0, 3, size = (2, 3)) 或者np.random.uniform(0, 3, (2, 3))

np.random.seed(10)加上随机种子，只要随机种子一样就会产生相同的随机数

①np.random.rand(shape)产生形状为shape 、值为 [0, 1) 范围内的浮点随机数
a = np.random.rand()  #0.575695284381402
b = np.random.rand(2) #[0.50852146 0.17941441]
a = np.random.rand(5) #[0.78489889 0.33281311 0.98805554 0.29558407 0.68429617]
c = np.random.rand(2,3)
'''
[[0.07689737 0.17578407 0.16941739]
 [0.63075319 0.86015553 0.88239051]]                                                
'''

②np.random.randint(low, high, size = )，产生产生形状为size, 值为 [low, high) 范围内的整型随机数
a = np.random.randint(0, 3)    #2                                                             
b = np.random.randint(3, size = 4)  #[0 2 1 1]
c = np.random.randint(0, 3, size = (2, 3))
'''
[[2 1 1]
 [0 1 0]]
'''

③np.random.randn(shape)产生形状为shape的标准正态分布的随机数
a = np.random.randn(3)  #[ 0.2203204   1.73158706 -0.78638403]
b = np.random.randn(2, 3)
'''
[[ 0.44799247 -0.37243396 -0.57481381]
 [ 0.17644269  0.99336282 -0.55967673]]
'''


⑤np.random.normal(μ, σ, size = )# 产生形状为size的正态分布
a = np.random.normal(0.1, 2.0, 3)  #[ 1.31578944 -1.16272895  2.50095739]
b = np.random.normal(0.1, 2.0,size = (2, 3))   
'''
[[ 2.07134546 -0.62086584 -0.32091925]
 [ 0.2286672  -1.13700916  0.09206429]]
'''

⑥np.random.poisson(lam,size=)产生shape为size，随机事件发生概率为lam的泊松分布

⑦np.random.uniform(low, high, size =)，产生shape为size范围在[low, high)内的均匀分布
a = np.random.uniform(3, size = 4)     #[2.65418547 1.65702115 2.42128949 2.74215319] 
b = np.random.uniform(0, 3)    #1.253105912177019
c = np.random.uniform(0, 3, size = (2, 3))    
'''
[[2.11947645 2.85662794 2.33596866]
 [0.86552208 2.9166298  1.55980368]]
'''                                                          

b=np.random.shuffle(a)
b=np.random.permutation(a)

c=np.random.choice(b,(3,2),p)  #以概率p从b中抽取一些元素组成形状为(3,2)的数组
c=np.random.choice(b,(3,2),replece=False,p) #以概率p从b中抽取一些元素组成形状为(3,2)的数组，而且不能重复取相同的元素

①np.random.rand(shape)产生形状为shape, 值为 [0, 1) 范围内的浮点随机数

import numpy as np

# 默认shape = 1, 产生[0, 1)范围内的一个浮点随机数
a = np.random.rand() 

# shape= 2, 产生[0, 1)范围内的2个浮点随机数，组装在一个列表里
b = np.random.rand(2) 

# shape = 5, 产生[0, 1)范围内的5个浮点随机数，组装在一个列表里
a = np.random.rand(5) 

# shape=(2,3), 产生[0, 1)范围内的二维数组（矩阵）的浮点随机数
c = np.random.rand(2,3) 



0.575695284381402
-----------------------
[0.50852146 0.17941441]
-----------------------
[0.78489889 0.33281311 0.98805554 0.29558407 0.68429617]
------------------------------------------------------------
[[0.07689737 0.17578407 0.16941739]
 [0.63075319 0.86015553 0.88239051]]

②np.random.randint(low, high = None, size = None)，产生产生shape为size, 值为 [low, high) 范围内的整型随机数

import numpy as np

# low = 0, high = 3, 产生[0, 3)范围内的一个整型随机数
a = np.random.randint(0, 3)

# low = 3, 产生[0, 3)范围内的一维数组（向量）的整型随机数
b = np.random.randint(3, size = 4)

# low = 0, high = 3, 产生[0, 3)范围内的二维数组（矩阵）的整型随机数
c = np.random.randint(0, 3, size = (2, 3))

print(a)
print(b)
print(c)

2
-----------------------
[0 2 1 1]
-----------------------
[[2 1 1]
 [0 1 0]]

③np.random.randn(shape)产生形状为shape的标准正态分布的随机数

import numpy as np

# 从标准正态部分中随机采样3个随机数
a = np.random.randn(3)

# 从标准正态分布中随机采样2 × 3个随机数，组成(2, 3)的二维数组（矩阵）
b = np.random.randn(2, 3)

print(a)
print(b)

[ 0.2203204   1.73158706 -0.78638403]
----------------------------------------------
[[ 0.44799247 -0.37243396 -0.57481381]
 [ 0.17644269  0.99336282 -0.55967673]]

④seed(s)随机种子值为s的随机种子

⑤np.random.normal(μ, σ, size=) 产生形状为size的正态分布
参数：

• 期望μ，μ是正态分布的位置参数，描述正态分布集中趋势位置，与μ邻近的概率值越大，而远离μ的概率值越小。正态分布以X =
  μ为对称轴，左右完全对称。正态分布的期望、均数、中位数、众数相同，均等于μ；
• 标准差σ，σ描述正态分布数据的离散程度，σ越大，数据的分布越分散，σ越小，数据分布越集中。σ也称为正态分布的形状参数，σ越大，曲线越扁平，反之，σ越小，曲线越高瘦；

import numpy as np

mu, sigma = 0.1, 2.0

# 从μ = 0.1, σ = 2.0的正态部分中随机采样3个随机数
a = np.random.normal(mu, sigma, 3)

# 从μ = 0.1, σ = 2.0的正态部分中随机采样2 × 3个随机数，组成(2, 3)的二维数组（矩阵）
b = np.random.normal(mu, sigma, size = (2, 3))

print(a)
print(b)


[ 1.31578944 -1.16272895  2.50095739]

[[ 2.07134546 -0.62086584 -0.32091925]
 [ 0.2286672  -1.13700916  0.09206429]]

⑥np.random.poisson(lam,size=)产生形状为size，随机事件发生概率为lam的泊松分布
⑦np.random.uniform(low, high, size = )，产生形状为size范围在[low, high)内的均匀分布

import numpy as np

# 产生shape为size范围在[low, high)内的均匀分布

# low = 3, 输出向量, shape = (4, )
a = np.random.uniform(3, size = 4)

# low = 0, high = 3, 输出为标量, shape = ()
b = np.random.uniform(0, 3)

# low = 0, high = 3, 输出为矩阵, shape = (2, 3)
c = np.random.uniform(0, 3, size = (2, 3))

print(a)
print(b)
print(c)

[2.65418547 1.65702115 2.42128949 2.74215319]

1.253105912177019

[[2.11947645 2.85662794 2.33596866]
 [0.86552208 2.9166298  1.55980368]]

⑧

6. numpy的统计函数

• np.sum(a,axis=0或1) 根据给定轴求和
• np.min(a,axis=0或1) 与np.max(a,axis=0或1) 计最小值，最大值
• np.ptp(a,axis=0或1) 计算最大值与最小值的差
• np.median(a,axis=0或1) 计算中位数（中值）
• np.mean(a,axis=0或1) 根据给定轴求均值
• np.average(a,axis=0或1,weights=None) 根据给定轴计算加权平均值
  比如：(np.average(a,axis=0或1,weights=[10,8,6]) )
• np.std(a,axis=0或1) 根据给定轴求标准差
• np.var(a,axis=0或1) 根据给定轴求方差

---

• np.argmin(a) 与np.argmax(a) 计算数组a中元素最小值，最大值的降一维后下标
• np.unravel_index(np.argmax(a),a.shape)计算数组a中元素最小值，最大值在数组a中的下标
• np.unravel_index(index,shape) 根据shape将一维下标index转换成多维下标

求方差也好，求均值罢：
axis=0就是按列计算，那么有几列结果就是几个值；
axis=1就是按行计算，有几行返回结果就是几个值。

axis=1就是在横轴上求，那么给权重时要给出每一列的权重值，最后返回的是每一行的加权平均的计算结果
import numpy as np 
a = np.arange(6).reshape(3,2)  
'''
[[0 1]
 [2 3]
 [4 5]]
'''

avg=np.average(a, axis = 1, weights =[3,5]) #按行计算，有三行所以返回三个值
print(avg)
'''
[0.625 2.625 4.625]
'''



axis=0就是在纵轴上求，那么给权重时要给出每一行的权重值，最后返回的是每一列的加权平均的计算结果
import numpy as np
a=np.arange(15).reshape(3,5)
'''
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
'''
print(np.average(a,axis=0,weights=[10,5,1]))  #按列计算，有几列返回几个值
'''
[2.1875 3.1875 4.1875 5.1875 6.1875]
'''



axis=0就是在纵轴上求，最后返回的是每一列的的计算结果
import numpy as np 
a = np.array([[1,2,3],[3,4,5],[4,5,6],[7,8,9]])  
'''
[[1 2 3]
 [3 4 5]
 [4 5 6]
 [7 8 9]]
'''

print (np.mean(a))
'''4.75 '''

print (np.mean(a, axis =  0))
'''
[3.75 4.75 5.75]
'''

• np.argmin(a) 与np.argmax(a) 计算数组a中元素最小值，最大值的降一维后下标
• np.unravel_index(np.argmax(a),a.shape)计算数组a中元素最小值，最大值在数组a中的下标
• np.unravel_index(index,shape) 根据shape将一维下标index转换成多维下标
  
  

7. numpy的梯度函数

（是右侧减去左侧（即a、b、c中(c-a)/2 ））

8. numpy的存储与读取

①二维数组的存储与读取






②多维数组的存储与读取