工具: anaconda,
win7只支持到py3.8,对应的anaconda是Anaconda3-2021.05-Windows-x86_64.exe
conda list: 显示当前已安装的软件包及版本
额外安装时，使用pip，如： pip install seaborn
离线安装预编译好的软件，使用如下站点搜索：https://www.lfd.uci.edu/~gohlke/pythonlibs/
运行Jupyer Notebook:
E:\Programs\Anaconda3\python.exe E:\Programs\Anaconda3\cwp.py E:\Programs\Anaconda3 E:\Programs\Anaconda3\python.exe E:\Programs\Anaconda3\Scripts\jupyter-notebook-script.py "%USERPROFILE%/"
2.Numpy
1）、引入numpy
import numpy as np
引入numpy，并且给numpy取一个别名为np
2)、数组：
arr=[1,2,3,4,5]
arr+1
对其进行加1操作会报错
TypeError: can only concatenate list (not "int") to list
我们使用numpy的array来创建数组
arr2=np.array(arr1)
print(arr2)
结果： [2 3 4 5 6]
查看arr1和arr2的类型
print(type(arr1))
print(type(arr2))
结果是：
<class 'list'>
<class 'numpy.ndarray'>
可见输出arr2的数据类型是ndarray，也就是numpy的底层数据类型，后续继续各种矩阵操作的基本数据类型就是它。
print(arr2+1)
print(arr2*(arr2+1))
结果是：
[2 3 4 5 6]
[ 2 6 12 20 30]
对numpy的数组执行加1操作时，是对数组中各个元素进行操作。
如果数组操作的对象是和它规模一样时，其结果是对应位置进行计算
3）、数组特性：
shape：表示查看数组或矩阵的维数
ex：
c=np.array([[1,1],[1,2],[1,3],[1,4]])
print(c.shape)
print(c)
结果是：
(4, 2)
[[1 1]
[1 2]
[1 3]
[1 4]]
可以简单理解为4行2列
普通的python数组没有shape属性，所以进行数据分析和处理时，使用numpy工具会更方便一些，展示的结果也会更丰富。
二维和多维数组也类似，只需要在array中传入二维/多维数组即可。
numpy多维数组：
marry=np.array(
[
[
[1,2,10,20],
[3,4,30,40]
],
[
[4,5,40,50],
[5,6,50,60]
],
[
[6,7,60,70],
[7,8,70,80]
]
]
)
marry.shape
结果为：(3, 2, 4)
#多维数据可以这么理解：
#在紧贴最外层的"[]"内有几个"[]"对，则shape的第一个元素就是几，比如上面的marry中，紧贴最外层的"[]"内有3对"[]",则shape的第一个元素就是3
#然后递归分析这三对次外层的"[]"对，以：[[1,2,10,20],[3,4,30,40]] 为例，
紧贴最外层"[]"有两对"[]",分别是:[1,2,10,20]和[3,4,30,40],所有shape的第二个值是2，
#最后递归分析这两对"[]",以[1,2,10,20]为例，里面有4个元素，所有shape第三个值为4
#marry的维度为3
marry.ndim
结果为：3
#索引，求marry第二个元素中的第二个元素中的第四个元素，结果为60
marry[1,1,3]
#求和：
marry.sum() #638
#按第一个维度(axis=0)求和：第一个维度不存在了，因为shape是（3，2，4），第一个维度不存在了，所以结果应该是（2，4），即：结果应该是2行4列
marry.sum(axis=0)
结果为：
array([[ 11, 14, 110, 140],
[ 15, 18, 150, 180]])可以这么计算： #按照哪一个维度计算，就把那个维度放到最内层的循环
res=np.array([[0,0,0,0],[0,0,0,0]])
for j in range(0,2):
for k in range(0,4):
res[j,k]=0
for i in range(0,3):
res[j,k] = res[j,k]+marry[i,j,k] #这个一定要按照shape的顺序来写
#print(res[j,k])
print(res)
结果也是一样的：
[[ 11 14 110 140] [ 15 18 150 180]]
#按第二维度(axis=1)求和： 就是第二个维度不存在了，第二个维度代表有两个数组的，现在不存在了，就相当于是每两个数组进行了加和，
#以[1,2,10,20],
[3,4,30,40] 为例，加起来，就是：[4,6,40,60]
marry.sum(axis=1)
结果：
array([[ 4, 6, 40, 60],
[ 9, 11, 90, 110],
[ 13, 15, 130, 150]])可以这么计算： #按照哪一个维度计算，就把那个维度放到最内层的循环
res=np.array([[0,0,0,0],[0,0,0,0],[0,0,0,0]])
#res.shape(2,4)
for j in range(0,3):
for k in range(0,4):
res[j,k]=0
for i in range(0,2):
res[j,k] = res[j,k]+marry[j,i,k],#这个一定要按照shape的顺序来写,此时变成j,i,k了
#print(res[j,k])
print(res)
结果：
[[ 4 6 40 60] [ 9 11 90 110] [ 13 15 130 150]]
#按第三维度(axis=2)求和： 简单理解一下，就是第三个维度不存在了，第三个维度本来是4列，现在不存在了，相当于是把4列数据加起来了。
#以[1,2,10,20],
[3,4,30,40] 为例，加起来，1+2+10+20=33 , 3+4+30+40=77 就是：[33,77]
marry.sum(axis=2)
结果：
array([[ 33, 77],
[ 99, 121],
[143, 165]])可以这么计算： #按照哪一个维度计算，就把那个维度放到最内层的循环
res=np.array([[0,0],[0,0],[0,0]])
#res.shape(2,4)
for j in range(0,3):
for k in range(0,2):
res[j,k]=0
for i in range(0,4):
res[j,k] = res[j,k]+marry[j,k,i]#这个一定要按照shape的顺序来写,此时变成j,k,i了
#print(res[j,k])
print(res)
结果：
[[ 33 77] [ 99 121] [143 165]]
使用ndarray数组时，注意：数据所有元素必须为同一类型，如果不是，则会自动向下转换。
arr4=np.array([1,2,3,4,'5'])
arr5=np.array([1,2,3,4,5.0])
print(arr4)
print(arr5)
arr6=np.array([1,2,3,4.0,'5'])
print(arr6)
结果是：
['1' '2' '3' '4' '5']
[1. 2. 3. 4. 5.]
['1' '2' '3' '4.0' '5']
ndarray中所有元素必须为同一类型，否则自动往下转换，顺序是：int->float->str
其他属性：
》1.使用type，打印当前数组的类型
print(type(arr1))
print(type(arr2))
结果是：
<class 'list'>
<class 'numpy.ndarray'>
》2.使用dtype，打印当前数组元素的数据类型
arr2.dtype
结果是：
dtype('int32')
》3.使用size，打印当前数组元素的个数
print(arr3.size)
结果是：
15
》4.使用ndim，打印当前数组的维度
print(arr3.ndim)
结果是：
2
3）、索引和切片：
对arr2进行索引和切片操作
print(type(arr2))
print(arr2)
print(arr2[1:3])
结果是：
<class 'numpy.ndarray'>
[1 2 3 4 5]
[2 3]
其中[1:3]左闭右开，索引从0开始，即选择数组中索引为1和2的元素
print(arr2[-2:])
结果是：
[4 5]
负数索引表示从后开始取数据，其中索引为-1的表示数组最后一个元素，[-2:]表示从倒数第二个元素开始取到最后。
索引操作在二维数组中同理，而且可以基于索引位置进行赋值操作。
tarry=np.array([[1,2,3],[3,4,5],[5,6,7]])
tarry[2,2]=100 #把索引为2的子数组中索引为2的元素变更为100
tarry
结果是：
array([[ 1, 2, 3],
[ 3, 4, 5],
[ 5, 6, 100]])
不仅可以针对某个元素赋值，还可以对某行或某列进行操作
ex：取第3行数据
tarry[2] #或者tarry[2,:] ,其中":"表示所有列
结果为：
array([ 5, 6, 100])
取第二列数据：注意：":"出现在第一个位置，相当于全部行的意思
tarry[:,1]
结果为：
array([2, 4, 6])
bool索引：
索引操作中，不仅可以使用具体位置进行索引，还可以使用布尔类型
tarry=np.arange(0,100,10)
tarry
结果为：
array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
arange(0,100,10): 表示从0到100，每隔10个数取一个元素
mask=np.array([0,0,0,1,1,1,0,0,1,1],dtype=bool)
mask
结果为：
array([False, False, False, True, True, True, False, False, True,
True])
mask为一个布尔类型的数组，1表示真，0表示假，分别对应结果中的True和False，下面通过布尔类型的索引来获取数值。
tarry[mask]
结果为：
array([30, 40, 50, 80, 90])
以上取得了所有索引位置为True的元素。
实际处理数据中，经常做各种判断，布尔类型还可以判断判断获得。
rarry=np.random.rand(10)
rarry
结果为：
array([0.84823665, 0.2907326 , 0.59065329, 0.89345843, 0.78551231,
0.0709826 , 0.37022162, 0.40259837, 0.01399967, 0.03760504])
其中rand(10)表示在[0,1)之间随机获得10个数。
mask=rarry>0.5
mask
结果为：
array([ True, False, True, True, True, False, False, False, False,
False])
判断其中每个元素是否符合要求，返回布尔类型。
用索引获取数据时也可以更灵活一些，直接将判断条件放在数组中也是可以的。
#找出符合条件要求的索引位置
tarry=np.array([10,20,30,4,50])
np.where(tarry>=30)
结果是：
(array([2, 4], dtype=int64),)
即数组中，值大于等于30的元素的索引是2和4
#按照满足要求的索引获得元素值
tarry[np.where(tarry>=30)]
结果为：
array([30, 50])
#bool还可以放在两个数组比较中
x=np.array([1,2,3,4,5])
y=np.array([1,2,3,5,6])
x==y
结果为：
array([ True, True, True, False, False])
4）、数值类型与数值计算
操作和计算数据前一定弄清楚数据的类型
数据类型：
为满足不同操作的要求，创建数组时还可指定元素的数据类型
tarry=np.array([1,2,3,4,5],dtype=np.float32)
tarry
结果为：
array([1., 2., 3., 4., 5.], dtype=float32)
拿到一个数组时，也可以调用其dtype属性来观察
tarry.dtype
结果为：
dtype('float32')
在numpy中字符串的名字叫object
sarry=np.array(['1','2','str','4'],dtype=object)
sarry
结果为：
array(['1', '2', 'str', '4'], dtype=object)
对创建好的数组进行类型转换：
tarry=np.array([1,2,3,4,5])
tarry2=np.asarray(tarry,dtype=np.float32)
tarry
tarry2
结果为：array([1, 2, 3, 4, 5])
array([1., 2., 3., 4., 5.], dtype=float32)
5）、赋值与复制
#将tarry赋值为t1，使用”=“进行赋值，此时他们是相同的，改变一个数组中的元素，另一个数组中的元素也会发生变化。
tarry=np.array([1,2,3,4,5])
t1=tarry
t1[1]=1000
print(tarry)
print(t1)
结果为：
[ 1 1000 3 4 5]
[ 1 1000 3 4 5]
如何让两个数组变得无关呢？
t2=tarry.copy()
t2[2]=3000
print(t2)
print(tarry)
结果为：
[ 1 1000 3000 4 5]
[ 1 1000 3 4 5]
#数值运算
之前介绍了创建数组，数据索引和查询，下面介绍数组的数值运算
##对所有元素进行求和
tarry=np.array([[1,2,3],[4,5,6]])
np.sum(tarry)
结果：
21
#对于一个二维数组来说，即可对列求和，也可以对行求和，用于统计不同的指标，需要额外的一个参数
#指定axis参数表示可以按照第几个维度进行计算，有些会超过二维，此时需要明确如何进行计算。
####存疑
#axis=0时，是对【列】进行求和
np.sum(tarry,axis=0)
结果为：
array([5, 7, 9])
#axis=1时，是对【行】进行求和
np.sum(tarry,axis=1)
结果为：
array([ 6, 15])
numpy中的其他计算操作方法：
#所有元素累乘：
tarry.prod()
结果：720
#指定维度求积（按【列】求积）
tarry.prod(axis=0)
结果：
array([ 4, 10, 18])
#指定维度求积（按【行】求积）
tarry.prod(axis=1)
结果：
array([ 6, 120])
#所有元素中的最小值
tarry.min()
结果：
1
#指定维度元素中的最小值（按【列】）
tarry.min(axis=0)
结果：
array([1, 2, 3])
#指定维度元素中的最小值（按【行】）
tarry.min(axis=1)
结果：
array([1, 4])
#所有元素求平均值
tarry.mean()
结果：
3.5
#指定维度元素求平均值（按【列】）
tarry.mean(axis=0)
结果：
array([2.5, 3.5, 4.5])
#指定维度元素求平均值（按【行】）
tarry.mean(axis=1)
结果：
array([2., 5.])
#所有元素求标准差
tarry.std()
结果：
1.707825127659933
#指定维度元素求标准差（按【列】）
tarry.std(axis=0)
结果：
array([1.5, 1.5, 1.5])
#指定维度元素求标准差（按【行】）
tarry.std(axis=1)
结果：
array([0.81649658, 0.81649658])
#所有元素求方差
tarry.var()
结果为：
2.9166666666666665
#比2小的全部为2，比4大的全部为4
tarry.clip(2,4)
结果为：
array([[2, 2, 3],
[4, 4, 4]])
#四舍五入
tarry1=np.array([1.2,3.56,6.4])
tarry1.round()
结果为：
array([1., 4., 6.])
#四舍五入保留精度
tarry1.round(decimals=1)
结果为：
array([1.2, 3.6, 6.4])
#如果不需要找到最大最小值，仅仅只需要知道其索引的话，可以这么处理
#所有元素的最小值的索引
tarry.argmin()
结果为：0
#指定维度元素的最小值索引（按【列】）
#可以这么理解运行结果，每一列中的最小值的索引为[0,0,0]
tarry.argmin(axis=0)
结果为：
array([0, 0, 0], dtype=int64)
#指定维度元素的最小值索引（按【行】）
#可以这么理解运行结果，每一行中的最小值的索引为[0,0]
tarry.argmin(axis=1)
结果为：
array([0, 0], dtype=int64)
6）、矩阵乘法
两种计算方式，一种是：按对应位置元素进行相乘，另一种是：在数组中进行矩阵乘法
x=np.array([5,5])
y=np.array([2,2])
print(x.shape)
print(y.shape)
print(np.multiply(x,y))
print(np.multiply(y,x))
print(np.dot(x,y))
print(np.dot(y,x))
结果是：
(2,)
(2,)
[10 10]
[10 10]
20
20
如果改变了数组的维度，结果就不同了。
x=np.array([5,5])
y=np.array([2,2])
#改变y的维度
y.shape=1,2
y ======>array([[2, 2]])
#改变x的维度
x.shape=2,1
x ======>array([[5],
[5]])
则x和y做矩阵相乘
np.dot(x,y)
结果为：
array([[10, 10],
[10, 10]])
#y和x做矩阵相乘
np.dot(y,x)
结果为：
array([[20]])
#其维度为
print(np.dot(x,y).shape)
print(np.dot(y,x).shape)
结果为：
(2, 2)
(1, 1)
7）、常用功能模块： Page36
》1.排序操作
import numpy as np
xx=np.array([[1.5,1.3,7.5],[5.6,7.8,1.2]])
print(xx.shape)
print(np.sort(xx))
print(np.sort(xx,axis=0)) #排序后，每一列是有序的
print(np.sort(xx,axis=1)) #排序后，每一行是有序的
结果：
(2, 3)
[[1.3 1.5 7.5]
[1.2 5.6 7.8]]
[[1.5 1.3 1.2]
[5.6 7.8 7.5]]
[[1.3 1.5 7.5]
[1.2 5.6 7.8]]
排序后，想使用元素的索引位置代替排序后的实际结果的
np.argsort(xx,axis=1) #排序后，每一行是有序的，
array([[1, 0, 2],
[2, 0, 1]], dtype=int64)
np.argsort(xx,axis=0) #排序后，每一列是有序的
array([[0, 0, 1],
[1, 1, 0]], dtype=int64)
ex:
yy=np.linspace(0,10,10)
yy
结果：
array([ 0. , 1.11111111, 2.22222222, 3.33333333, 4.44444444,
5.55555556, 6.66666667, 7.77777778, 8.88888889, 10. ])
可以理解为首项为0，第10项为10的等差数列，所以公差d=(10-0)/(10-1)=1.11111...
linspace(0,10,10): 表示在0-10之间等距离产生10个数字
如果此时新增一组数据，将按照大小顺序把它们插入刚生成的数据，该如何放置呢?
ex:
ny=np.array([2.5,6.5,9.5])
np.searchsorted(yy,ny)
结果为：
array([3, 6, 9], dtype=int64)
注意：这个索引是ny插入到yy的位置（从0开始），比如2.5应该放在3.33333333，3.33333333的索引是3，所以2.5应该插入的位置是3，同样6.5应该是6.66666667之前，6.66666667的索引是6，千万不要理解为2.5插入y之后，6.66666667的位置后移一位，索引变成7。
如何将数据按照某一指标进行排序呢?例如按照第一列的升序／降序或对整体数据进行排序呢？
ex:
tarr=np.array([ [1,0,6],[1,7,0],[2,3,1],[2,4,0] ])
#此时得到的就是按照第一列降序后的索引，再把索引传入原数组即可。
# -1表示降序
idx = np.lexsort([-1*tarr[:,0]])
idx
结果：
array([2, 3, 0, 1], dtype=int64)
tarr[idx]
结果：
array([[2, 3, 1],
[2, 4, 0],
[1, 0, 6],
[1, 7, 0]])
#此时得到的就是按照第一列升序后的索引，再把索引传入原数组即可。
idx1=np.lexsort([tarr[:,0]])
idx1
结果：
array([0, 1, 2, 3], dtype=int64)
升序排序结果查看：
tarr[idx1]
结果：
array([[1, 0, 6],
[1, 7, 0],
[2, 3, 1],
[2, 4, 0]])
》2.数组形状操作
对数组进行操作时，为满足格式和计算要求，通常会要求改变其形状。
#创建一个数组，默认从0开始，arange函数的结果通常可作为索引
t1=np.arange(10)
t1
结果：
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
t1.shape
结果：
(10,)
改变形状：
t1.shape=2,5
t1
结果为：
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
#可以通过shape改变数组形状，但变换前后元素个数保持一致。
#创建一个数组后，还可以给他增加一个维度，这在矩阵计算经常遇到：
t2=np.arange(10)
t2=t2[np.newaxis,:]
t2
结果为：
array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
t2.shape
(1, 10)
#也可以对数组进行压缩操作，把多余维度去掉
t2=t2.squeeze()
t2
结果：
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
t2.shape
结果为：
(10,)
#矩阵转置操作：
t2=np.arange(10)
t2.shape=(2,5)
t2
结果为：
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
如何转置：
t3=t2.transpose()
t3
结果为：
array([[0, 5],
[1, 6],
[2, 7],
[3, 8],
[4, 9]])
更直接一些的是：
t2.T
结果：
array([[0, 5],
[1, 6],
[2, 7],
[3, 8],
[4, 9]])
》3.数组拼接：concatenate
#简单记忆就是：拼接数组，就是将内容直接按行追到到最后。即：纵向追加，行数增加了
a=np.array([[1,2,3],[4,5,6]])
b=np.array([[7,8,9],[10,11,12]])
np.concatenate((a,b))
结果：
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])
还有一种追加维度的
#横向追加的，列数增加了。
np.concatenate((a,b),axis=1)
结果：
array([[ 1, 2, 3, 7, 8, 9],
[ 4, 5, 6, 10, 11, 12]])
另一种拼接方式：
d=np.array([1,2,3])
e=np.array([2,3,4])
np.stack((d,e))
结果：
array([[1, 2, 3],
[2, 3, 4]])
#原始数据是1维的，拼接后是2维的，相当于增加了一个维度，类似操作还有hstack和vstack,分别表示水平和竖直的拼接。在数据维度等于1时，他们的作用相当于是stack，用于创建新轴，当维度大于等于2时，他们作用相当于是concatenate,用于在已有轴上进行操作。
#竖直方向上拼接，相当于是concatenate
np.vstack((a,b))
结果：
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])
np.hstack((a,b))
结果：
array([[ 1, 2, 3, 7, 8, 9],
[ 4, 5, 6, 10, 11, 12]])
np.vstack((d,e))
结果：
array([[1, 2, 3],
[2, 3, 4]])
np.hstack((d,e))
结果：
array([1, 2, 3, 2, 3, 4])
多维数组拉平：
arr=np.array([[7,8,9],[10,11,12]])
print(arr.flatten())
print(arr)
结果：
[ 7 8 9 10 11 12]
[[ 7 8 9]
[10 11 12]]
》4.创建数组函数
创建数组最简单的就是np.array()，其他的还有：
#取值范围是[2,20),间隔为2
np.arange(2,20,2)
结果：
array([ 2, 4, 6, 8, 10, 12, 14, 16, 18])
#一些特殊的函数，默认以10为底
np.logspace(0,1,5)
结果：
array([ 1. , 1.77827941, 3.16227766, 5.62341325, 10. ])
#快速创建行向量,
np.r_[0:5:1]
结果：
array([0, 1, 2, 3, 4])
rr=np.r_[0:5:1]
print(rr.shape)
print(rr)
结果：
(5,)
[0 1 2 3 4]
#快速创建列向量：
np.c_[0:7:1]
array([[0],
[1],
[2],
[3],
[4],
[5],
[6]])
cc=np.c_[0:7:1]
print(cc.shape)
print(cc)
结果：
(7, 1)
[[0]
[1]
[2]
[3]
[4]
[5]
[6]]
以上函数虽然可以快速创建数组，在机器学习任务中需要初始化参数，需要用常量值或随机值来创建一个固定大小的矩阵
#创建0矩阵，包含10个元素
np.zeros(10)
结果：
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
#参数有两个括号，参数是：(10,10) 表示10×10的0矩阵
np.zeros((10,10))
结果：
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])
#ones()表示单位矩阵，如传入(5,5),表示5×5的单位矩阵
np.ones((5,5))
结果：
array([[1., 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((3,3))*8
结果：
array([[8., 8., 8.],
[8., 8., 8.],
[8., 8., 8.]])
#也可以先创建空的，指定其大小，然后往里面填充值
a=np.empty(6)
a
结果：
array([2.065e-321, 0.000e+000, 0.000e+000, 0.000e+000, 0.000e+000,
0.000e+000])
a.fill(1)
a
结果：
array([1., 1., 1., 1., 1., 1.])
#先创建一个数组，初始化一个0矩阵，让它和数组的维度一致。
t=np.array([1,2,3,4])
tt=np.zeros_like(t)
tt
结果：
array([0, 0, 0, 0])
#对角阵，只有对角线有数，并且为1
tt=np.identity(5)
print(tt)
print(tt.shape)
结果：
array([[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.]])
(5, 5)
》5.随机模块
初始化参数、切分数据集、随机采样会用到随机模块
#创建一个3行2列的矩阵
np.random.rand(3,2)
结果：
array([[0.7937855 , 0.61947744],
[0.15826968, 0.89196895],
[0.45667576, 0.87739669]])
#返回区间[0,10)的随机整数，规模为5行6列
np.random.randint(10,size=(5,6))
结果：
array([[0, 7, 8, 9, 9, 2],
[5, 6, 9, 0, 7, 6],
[7, 8, 3, 0, 5, 0],
[9, 1, 8, 5, 8, 5],
[9, 8, 6, 9, 0, 7]])
#只想返回一个随机值
np.random.rand()
结果为：
0.2185737816817599
#指定区间并选择随机个数
np.random.randint(0,5,3)
结果：
array([2, 4, 1])
#指定分布及所需参数进行随机，如高斯分布中的mu和sigma
#符合均值为0，标准差为0.1的高斯分布的随机数
#mu：有问题！！！
np.random.normal(mu,sigma,10)
#指定返回结果中的小数位数
#ex:指定3位小数
np.set_printoptions(precision=3)
np.random.normal(mu,sigma,10)
#机器学习中很多算法要求数据之间相互独立，所以需要先对数据集进行洗牌操作
tt=np.arange(10)
#每次执行结果都不一样
np.random.shuffle(tt)
》6.写文件
#numpy写文件：
%%writefile tmp.txt
1 3 5 6 7
2 4 6 8 10
结果：
Writing tmp.txt
#numpy读文件
dat=np.loadtxt('tmp.txt')
dat
结果：
array([[ 1., 3., 5., 6., 7.],
[ 2., 4., 6., 8., 10.]])
#如文件中带有分隔符，还需要指定分隔符
dat=np.loadtxt('tmp.txt',delimiter=',')
#查看函数功能
print(help(np.loadtxt))
部分结果：
Help on function loadtxt in module numpy:
loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None, *, like=None)
Load data from a text file.
#savetxt
np.savetxt('tmp.txt',arr,fmt='%d',delimiter=',')
#numpy中还有一种".npy"格式，即把数据保存为ndarray格式，这种方式可以把程序运行结果保存下来，如：将建立机器学习模型求得的参数保存成".npy"格式，再次使用时直接加载就好。
ex:
arr=np.array([[1,2,3],[4,5,6]])
#将结果保存为npy格式
np.save('1.npy',arr)
#读取之前保存的结果，依旧是numpy的数组格式化
np.load('1.npy')
结果：
array([[1, 2, 3],
[4, 5, 6]])
但如果直接打开1.npy，则是乱码文件
