php转python及人工智能之路
- python，大数据，机器学习，深度学习，计算机视觉
-
二、机器学习数据科学包(numpy、pandas、matpotlib)篇（一）numpy的基本使用之array
python，大数据，机器学习，深度学习，计算机视觉
二、机器学习数据科学包(numpy、pandas、matpotlib)篇（一）numpy的基本使用之array
环境搭建
前言
Linux一般都用VMware虚拟机，从装好系统到设置虚拟机NTA等模式访问外网再到本机和虚拟机相互通讯等等，一系列问题对于新手来说要花一些时间。
其实：这部分内容用windows环境即可！实际开发中，一般线上运行环境是linux，线下开发环境可能是win，mac或linux，都主要把自己的代码提交上linux上去运行的。
准备软件
win下安装软件：Anaconda、PyCharm
Anaconda是一个集成开发环境，自带python、numpy、pandas等，不多介绍，总之很火，自行百度。
PyCharm是IDE，简单说就是写代码和测试用的。
软件下载
因为这个国外网站被限速了，下载速度几十KB/s（请自行感受~），至于还有某种方法我就不说了，所以还是给你们个超高速率的下载地址：
清华大学镜像网站：https://mirrors.tuna.tsinghua.edu.cn/
直接搜索，下载，不用谢！
安装软件
1.Anaconda
直接下一步下一步，
关键点：
（1）软件安装到D:\Python\Anaconda3\目录（自定义）下，后面用到。因为我这只有一个C盘，下面以C:\Python\Anaconda3\为例描述。（有D盘的建议安到D盘，否则装C盘时间长了电脑卡！）
（2）添加环境变量，如下：
（3）安装后：
进入win命令窗口（win+r后，输入cmd），cd到anaconda安装目录（自己把软件装到哪里了），如下图。
输入conda list 查看都有哪些库，因为一般初次安装的包都比较老，为避免报错，输入conda update –all 更新所有的包，不再演示。
（4）测试是否安装好了Anaconda：
win+r，输入cmd，进入windows命令行模式，输入：jupyter notebook (或者输入：ipython notebook)
或者可以在开始搜索输入Jupyter Notebook，进入后会弹出命令框然后自动打开浏览器启动一个web服务，那里也可以对python代码编辑和运行，表示已成功安装好Anaconda。
注：.ipynb文件即ipython notebook的意思。
（5）测试是否安装好了numpy、pandas：（此为拓展知识，一般上一步测试通过即可~）
还是这个win命令行模式，输入python，进入python代码编辑模式，输入from numpy import *回车，再输入eye(4)回车，若出现一个数组的结果，说明安装好了numpy。
2.PyCharm
这个很简单，过程和正常IDE差不多，不多说了。
3.PyCharm整合Anaconda
New Project时候，要设置几处：
（1）Location项设置：自行设置，是放自己代码的
（2）Existing interpreter项设置：要选默认的Virtualen Environment。
- 要勾选Make available to all projects
- 要选C:\Python\Anaconda3\python.exe即将其添加进来
最后Create，即可使用PyCharm。
numpy属性
先灌输三个知识点：
- ndim：几维数组
- shape：数组形状，即数组多少行、多少列
- size：数组元素总个数
不要研究上面的了，直接看实战代码：
import numpy as np#一般习惯上把numpy简写成np
arr = np.array([[1,2,3],
[2,3,4]])
print(arr)
print('number of dim:',arr.ndim)# 几维数组
print('shape:', arr.shape)# 数组形状，即数组多少行、多少列
print('size', arr.size)# 数组元素总个数
运行结果：
[[1 2 3]
[2 3 4]]
number of dim: 2
shape: (2, 3)
size 6
numpy创建array及基础运算
知识点：
- dtype “定义类型格式”。
dtype即d type"定义类型格式"(d=define)。如dtype = np.int64 - zeros（或ones，twos…）“生成元素全为0（或1，2）的数组”；empty生成接近于0的数。
注意empty不是空什么都没有。如np.zeros((3,4))，np.ones((3,4))，np.empty((3,4)) - arange()“生成步长范围内的数”
等价python：range() 。如np.arange(10,20,2) - reshape((m,n))“重置矩阵形状为m行n列” 。或reshape(m,n)
re shape = reset shape。如np.arange(12).reshape((3,4)) - linspace(m,n,k)生成数段，把从m~n （含m,n） 均分成k份，
如a12 = np.linspace(0,9,4)
不懂的话直接看实战代码：
（1）
import numpy as np
a = np.array([2,23,4], dtype = np.int64)#dtype = d type"定义类型格式"(d=define)
print(a)# 结果：[ 2 23 4] #数组是以空格分隔的
print(a.dtype)#结果：int64
a2 = np.array([2,23,4], dtype = np.float32)
print(a2)# 结果：[ 2. 23. 4.]#小数
print(a2.dtype)# 结果：float32
运行结果：
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
（2）
import numpy as np
a = np.zeros((3,4))# 3行4列为元素全0的矩阵,默认小数类型
print(a3)
"""
运行结果：
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
"""
a2 = np.ones((3,4), dtype = np.int16)# 3行4列为元素全1的矩阵,定义类型为int16
print(a4)
"""
运行结果：
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
"""
a3 = np.empty((3,4))# empty不是空什么都没有，而是接近于0的数， 同样3行4列矩阵
print(a7)
"""
运行结果：
[[3.56043053e-307 1.37961641e-306 1.33508845e-306 1.33511969e-306]
[6.23037996e-307 1.11261434e-306 6.23059726e-307 1.11260348e-306]
[1.37962049e-306 2.22521238e-306 1.24611470e-306 3.91786943e-317]]
"""
a4 = np.empty((3,4), dtype = np.int16)# empty不是空什么都没有，而是接近于0的数， 同样3行4列矩阵
print(a5)
"""
运行结果：
[[ 176 -14741 32767 0]
[ 4704 -14741 32767 0]
[ 0 0 0 0]]
"""
a5 = np.empty((3,4), dtype = np.int8)# empty不是空什么都没有，而是接近于0的数， 同样3行4列矩阵
print(a6)
"""
运行结果：
[[-80 0 107 -58]
[ -1 127 0 0]
[ 96 18 107 -58]]
"""
（3）
import numpy as np
a = np.arange(10)# 等价python：range(10)
print(a8)# 结果[0 1 2 3 4 5 6 7 8 9]
a2 = np.arange(10,20,2)# 从10到20（不含20），步长2
print(a9)# 结果[10 12 14 16 18]
运行结果：
[0 1 2 3 4 5 6 7 8 9]
[10 12 14 16 18]
（4）
import numpy as np
#reshape(m,n)重置矩阵形状为m行n列 "re shape = reset shape"
a10 = np.arange(12).reshape((3,4))
print(a10)
运行结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
（5）
import numpy as np
#linspace(m,n,k)生成数段，把从m~n（含m,n）均分成k份，
a11 = np.linspace(1,10,5)
print(a11)# 结果[ 1. 3.25 5.5 7.75 10. ]
a12 = np.linspace(0,9,4)
print(a12)# 结果[0. 3. 6. 9.]
运行结果：
[ 1. 3.25 5.5 7.75 10. ]
[0. 3. 6. 9.]
numpy的基础运算1
知识点：
矩阵的加减乘、平方，np自带的sin/cos/arcsin/arccos，print“查找法”，随机矩阵。
以及np自带的函数sum()、min()、max()包括按行或列处理。
实战代码：
（1）矩阵的加减乘、平方
import numpy as np
a = np.array([10,20,30,40])# 创建矩阵
b = np.arange(4)# 等价python:range(4),生成矩阵[0 1 2 3]
print(a,'\n',b)
c = a-b#矩阵的减法
print(c)# [10 19 28 37]
c = a+b#矩阵的加法
print(c)#[10 21 32 43]
c = b**2# 平方
print(c)#[0 1 4 9]
a = np.array([[1,1],[0,1]])
b = np.arange(4).reshape((2,2))
print(a,'\n\n',b,'\n')
c = a*b# 普通的一一对应相乘
c_dot = np.dot(a,b)# 线代矩阵乘法运算
#也可以用下面写法，等价
c_dot2 = a.dot(b) #线代矩阵乘法运算
print(c,'\n\n',c_dot,'\n\n',c_dot2)
（2）np自带的sin/cos/arcsin/arccos
import numpy as np
a = np.array([10,20,30,40])# 创建矩阵
a0 = np.sin(10)
b0 = np.cos(3.14/2)
c0 = np.arcsin(0.5)
d0 = np.arccos(0.5)
print(a0,b0,c0,d0, sep='\n',end='注意这些是数字不是角度！')
c1 = np.sin(a)
c2 = 10*np.sin(a)
print('\n', c1, '\n', c2)#先输出换行，再输出c1
运行结果：
-0.5440211108893698
0.0007963267107332633
0.5235987755982989
1.0471975511965979注意这些是数字不是角度！
[-0.54402111 0.91294525 -0.98803162 0.74511316]
[-5.44021111 9.12945251 -9.88031624 7.4511316 ]
（3）print“查找法”：通过print可以查找某个元素或某个范围的元素。
import numpy as np
b = np.arange(4)# 等价python:range(4),生成矩阵[0 1 2 3]
print(b)
print(b < 3)
print(b == 3)
运行结果：
[0 1 2 3]
[ True True True False]
[False False False True]
（4）随机矩阵
import numpy as np
a = np.random.random((2,4))# 生成2行4列（共8个）随机数
print(a)
运行结果（随机）：
[[0.43301947 0.48940757 0.0772012 0.24322838]
[0.91813542 0.59199106 0.29202713 0.36738142]]
（5）np自带的函数sum()、min()、max()包括按行或列处理
import numpy as np
a = np.array([[2,20,5,6],[4,100,50,60]])
print(a)
print(np.sum(a))#将矩阵元素求和
print(np.min(a))#求矩阵元素最小值
print(np.max(a))#求矩阵元素最大值
print(np.sum(a, axis = 1))# 1表row，求每行之和，即row为单位（划分）进行求和。返回一个一维矩阵
print(np.sum(a, axis = 0))# 0表col，求每列之和，即col为单位进行求和。返回一个一维矩阵
print(np.min(a, axis = 1))# 1表row，求每行最小值，即row为单位求最小值。返回一个一维矩阵
print(np.min(a, axis = 0))# 0表col，求每列最小值，即col为单位求最小值。返回一个一维矩阵
print(np.max(a, axis = 1))# 1表row，求每行最大值，即row为单位求最大值。返回一个一维矩阵
print(np.max(a, axis = 0))# 1表col，求每列最大值，即col为单位求最大值。返回一个一维矩阵
运行结果：
[[ 2 20 5 6]
[ 4 100 50 60]]
247
2
100
[ 33 214]
[ 6 120 55 66]
[2 4]
[ 2 20 5 6]
[ 20 100]
[ 4 100 50 60]
注：严格地说，axis = 1表示row并不确切，应该表“水平”，暂时先这样好理解，具体后面讲分割（掰开）那部分的总结会讲到！
numpy的基础运算2
知识点：np自带的
- 关于下标的argmin, argmax, nonzero;
- 均值mean/average（包括分别以行/列为单位）, 中位数median;
- 累加cumsum, 累差diff; 限(上下)界clip;
- 行排序sort; 转置np.transpose(A)/A.T
（1）argmin：最小值下标（索引）。argmax：最大值下标。代码如下：
import numpy as np
A = np.array([[20,30,10],[1,2,3]])
print(A)
print(np.argmin(A))# 最小值下标（索引）。（若有重值，以第一个为准，按先来后到原则）
print(np.argmax(A))# 最大值下标。（若有重值，以第一个为准，按先来后到原则）
运行结果：
[[20 30 10]
[ 1 2 3]]
3
1
nonzero，分别列出索引元素对应的行下标、列下标，限非零元素。代码如下：
import numpy as np
A = np.array([[20,30,10],[1,2,3]])
print(A)
print(np.nonzero(A))# 分别列出索引元素对应的行下标、列下标，限非零元素
print(" ")
A2 = np.array([[20,30,10],[1,0,3]])#有零元素，不列，通过结果可以知道0元素在第几行第几列
print(A2)
print(np.nonzero(A2))
运行结果：
[[20 30 10]
[ 1 2 3]]
(array([0, 0, 0, 1, 1, 1], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))
[[20 30 10]
[ 1 0 3]]
(array([0, 0, 0, 1, 1], dtype=int64), array([0, 1, 2, 0, 2], dtype=int64))
分析：以第一个结果为例：(array([0, 0, 0, 1, 1, 1], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))的，前半部分：(array([0, 0, 0, 1, 1, 1], dtype=int64),是指元素20 30 10 1 2 3依次位于第0行、第0行、第0行、第1行、第1行、第1行；后半部分array([0, 1, 2, 0, 1, 2], dtype=int64))是指元素20 30 10 1 2 3依次位于第0列，第1列，第2列，第0列，第1列，第2列。
（2）均值mean/average（包括分别以行/列为单位）, 中位数median。代码如下：
import numpy as np
A = np.arange(2, 14).reshape((3, 4))
print(A)
print(np.mean(A))# 平均值
print(np.average(A))# 平均值（写法2）
print(np.median(A))#中位数
print(" ")
A = np.arange(8).reshape(2, 4)
print(A)
print(np.mean(A, axis=1))# 以row为单位求平均值
print(np.mean(A, axis=0))# 以col为单位求平均值
运行结果：
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
7.5
7.5
7.5
[[0 1 2 3]
[4 5 6 7]]
[1.5 5.5]
[2. 3. 4. 5.]
（3）累加cumsum，累加，相当于代码常写的sum+=… 。代码如下：
import numpy as np
A = np.arange(2, 14).reshape((3, 4))
print(A, '\n')
print(np.cumsum(A))#累加，相当于代码常写的sum+=...
运行结果：
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
[ 2 5 9 14 20 27 35 44 54 65 77 90]
分析：
[ 2 2+3 2+3+4 ...]
累差diff，后一个元素减前一个元素。代码如下：
import numpy as np
A = np.array([[20,30,10],[1,2,3]])
print(A)
print(np.diff(A))#累差
#[]
运行结果：
[[20 30 10]
[ 1 2 3]]
[[ 10 -20]
[ 1 1]]
分析：后一个元素减前一个元素
[[30-20 10-30]
[ 2-1 3-2]]
可以看到累差diff后，列数比原来减1
限(上下)界clip，限定上界下界范围不能越界，坐标系画上下两条线。代码如下：
import numpy as np
A = np.arange(14, 2, -1).reshape((3, 4))
print(A, '\n')
print(np.clip(A, 5, 9))# 限定上界下界范围不能越界。上界最大为9，下界最大为5
运行结果：
[[14 13 12 11]
[10 9 8 7]
[ 6 5 4 3]]
[[9 9 9 9]
[9 9 8 7]
[6 5 5 5]]
（4）行排序sort; 转置np.transpose(A)/A.T 。代码如下：
import numpy as np
A = np.arange(14, 2, -1).reshape((3, 4))
print(A)
print('以row为单位进行排序：')
print(np.sort(A))# 以row为单位进行排序
print('转置：')
print(A.T)#矩阵的转置---行变列，列变行
print('转置写法2：')
print(np.transpose(A))#矩阵的转置（写法2）
print('矩阵A乘以A的转置：')
print(A.dot(A.T))#A*A^T,矩阵A乘以A的转置。dot()为矩阵的乘法运算函数
print('矩阵A的转置乘以矩阵A：')
print((A.T).dot(A))# 即print(A.T.dot(A))。矩阵A的转置乘以A
运行结果：
[[14 13 12 11]
[10 9 8 7]
[ 6 5 4 3]]
以row为单位进行排序：
[[11 12 13 14]
[ 7 8 9 10]
[ 3 4 5 6]]
转置：
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
转置写法2：
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
矩阵A乘以A的转置：
[[630 430 230]
[430 294 158]
[230 158 86]]
矩阵A的转置乘以矩阵A：
[[332 302 272 242]
[302 275 248 221]
[272 248 224 200]
[242 221 200 179]]
numpy的索引
import numpy as np
#一维，大多用法和列表/数组都相同。
A = np.arange(3, 15)
print(A)
print(A[3])
#二维
A = np.arange(3, 15).reshape((3, 4))
print(A)
print(A[1])# 直接打印值，故是一维数组！
print(A[2][1])#输出A[2][1]。写法1
print(A[2, 1])#输出A[2][1]。写法2
print('第2行（下标1）到结尾：')
print(A[1:])# 截取！故结果是二维数组！
print('在第2行中取第2列到结尾：')
print(A[1][1:])# 截取！故结果是二维数组！
print('开头到第2行（下标1）：')
print(A[:2])#注意0~1(不含2)，即0,1，截取！故输出的是二维数组！
print('下面这个要理清：')
#下面这写法是根据上面的 ‘print(A[2, 1])#输出A[2][1]。写法2’写法来的。
#:表示占位符，表示所有变量x
print(A[1, :])#打印下标为1的行，结果是一维数组。等价print(A[1])
#【巧记】# 将“:” 替换 “所有x”。即print(A[1, 所有x])。
print(A[:, 2])#打印下标为2的列，结果是一维数组。等价pirnt(A[][2])
#【巧记】# 将“:” 替换 “所有x”。即print(A[所有x, 2])。
print(A[1, 1:3])#打印行下标为1且列下标1~2（不含3）的数，结果是一维数组
print(A[1, 1:2])#打印行下标为1且列下标1（不含2）的数，结果是一维数组
for row in A:
print(row)
print(A)
print(A.T)#A.T转置，行变列列变行
# 故实际开发中：我们可以通过转置改变遍历的先后顺序。
for col in A.T:#输出的是A.T的行，即原来A的列。
print(col)
print(A.flatten())# 矩阵转化成一维的列表
print(A.flat)# flat是存放上面flatten值的对象object
# 下面重点，其原理和列表生成器range()一样。
for item in A.flat:#迭代器，千万记住要用对象型的flat，不要用flatten。
print(item)
print(A.flatten)# 这个没啥意义，别弄混了
numpy之 array合并
前言
联想一下别的语言数组的合并array，如php array_merge(), array_combine()，加深理解！
知识点
import numpy as np
A = np.array([1, 1, 1])
B = np.array([2, 2, 2])
#vertical stack 竖直叠加
print(A.shape, C.shape)
#horizontal stack 水平叠加
C = np.hstack((A, B))#横向合并，左右连接起来
print(C)
D = np.vstack((A, B))#竖向合并，stack堆起来。第一个矩阵A变为第一行，第二个矩阵B变为第二行。生成二维矩阵。
print(D)
#二维以上的才是矩阵，一维是是序列
print(A.T)#A是序列[1, 1, 1]不是矩阵[[1, 1, 1]]，所以转置不管用。
#怎么让转置好用
# 法1，显然定义的时候就定义成矩阵
A = np.array([[1, 1, 1]])
print(A.T)
#法2，将一维序列再加一个维度变成二维矩阵
A = np.array([1, 1, 1])
print(A[np.newaxis, :])#使之变水平且行上加一个维度，列不变
print(A[np.newaxis, 1:3])#使之变水平且行上加一个维度，列取下标1~2（不含3）的
print(A[np.newaxis, :].T)#这时可以转置了。（写法1）
print(A[:, np.newaxis])#行不变，使之变竖直且列上加一个维度。注意了！与上个语句等价（写法2）
print(A[1:3, np.newaxis])#行取下标1~2（不含3）的，然后使之变竖直且列上加一个维度。
A = np.array([1, 2, 3])[:, np.newaxis]# 水平序列，使之变竖直纵向加一个维度。
B = np.array([4, 5, 6])[:, np.newaxis]
print(A)
print(B)
C = np.hstack((A, B))#h水平，horizontal。水平叠加。
D = np.vstack((A, B))#v竖直，vertical。竖直叠加
print(C)
print(D)
print(A.shape, D.shape)
# concatenate可以在合并的时候定义怎么合并，即包含了hstack和vstack的功能
#水平合并 写法1：
C = np.hstack((A, B))
print(C)
#水平合并 写法2：
C = np.concatenate((A, B), axis = 1)#水平合并
print(C)
#竖直合并 写法1：
C = np.vstack((A, B))
print(C)
#竖直合并 写法2：
C = np.concatenate((A, B), axis = 0)#竖直合并
print(C)
#在实际开发中，可以设定axis = x，通过控制x的值1或0来控制水平合并，比如if-else条件中，两部分功能差不多，不必写两段代码了。
# 多个array合并
C = np.hstack((A, B, B, A))
print(C)
#合并多个array
C = np.concatenate((A, B), axis = 1)#水平合并
print(C)
C = np.concatenate((A, B, B, A), axis = 0)#竖直合并
print(C)
numpy之 array分割（掰开）
重要话：
首先先说明一下，本部分array分割函数split() 、hsplit()、vsplit() 等，我不喜欢叫它们分割函数，而管它们叫“掰开函数”，简称“掰函数”！
为什么？下面会讲到本人Acegem原创的理解记忆法，让你受益匪浅。
引入正文
1.先来回顾一下，前面concatenate() 函数的代码运行结果，可以看到axis=1（水平），axis=0（竖直）。
import numpy as np
A = np.array([1, 2, 3])[:, np.newaxis]
B = np.array([4, 5, 6])[:, np.newaxis]
print(A)
print(B)
C = np.concatenate((A, B), axis = 1)#水平合并
print('合并结果；\n', C)
运行结果：
[[1]
[2]
[3]]
[[4]
[5]
[6]]
合并结果；
[[1 4]
[2 5]
[3 6]]
2.那么到了分割split这个函数啊，初学看着会懵！axis=1或0到底水平还是竖直？老手也有可能混淆。为什么？请再看下面的代码运行结果
仔细看我下面代码写的注释！！！（你会受益匪浅）：
import numpy as np
A = np.arange(12).reshape((3, 4))
print(A, '\n')
#分割记住一句话：不是用刀切，是用手掰！！！。按照我下面的记忆法！
print(np.split(A, 2, axis=1),'\n')#用手水平方向即左右掰开。不用理解成竖着一刀切。要记住axis=1指的是水平，这里是水平左右掰开
print(np.split(A, 3, axis=0),'\n')#竖直用手竖直方向即上下掰开。不用理解成横着着一刀切。要记住axis=0指的是竖直，这里是竖直上下掰开
运行结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
【注】：如果你写print(np.split(A, 2, axis=0),'\n')则会报错！因为A有3行，你想竖直上下掰开2份是不能均分的，由此可见，split() 这个函数是均分/等分，否则会报错。
3.如果想要实现不均等的掰开/分割，可以用array_split() 这个函数
import numpy as np
A = np.arange(12).reshape((3, 4))
print(A, '\n')
print(np.array_split(A, 2, axis=0),'\n')
运行结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
4.同样，与合并类似，掰开/分割也有两个函数hsplit() 水平掰！vsplit() 竖直掰！
import numpy as np
A = np.arange(12).reshape((3, 4))
print(A, '\n')
print(np.hsplit(A, 2),'\n')
print(np.vsplit(A, 3),'\n')
运行结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
【注】：同样如果你写print(np.vsplit(A, 2),'\n')也会报错！因为A有3行，你想竖直上下掰开2份是不能均分的，由此可见，hsplit()、vsplit() 这俩函数也是均分/等分的，否则会报错。
总结
这里再重复一遍！
分割记住一句话：不是用刀切，是用手掰！！！（本人Acegem自创记忆法）
【本质】：
axis = 1表横轴（水平方向从左到右），axis = 0表纵轴（竖直方向从上到下）。
对于axis=1或0的问题，官方是这么解释的：
轴用来为超过一维的数组来定义属性，二维数组拥有两个轴：第0轴沿着行的垂直往下，第1轴沿着列的方向水平延伸。1表示横轴，方向从左到右；0表示纵轴，方向从上到下。当axis=1时，数组的变化是横向的，而体现出来的是列的增加或者减少。
axis的重点在于方向，而不是行和列。具体到各种用法而言也是如此。
如当axis=1时：如果是求平均，那么是从左到右横向求平均；如果是增加，那么也是左右横向增加；如果是删除，那么也是横向发生变化，体现为列的减少。
总之，要想的是方向怎么变化，即axis=1为横向操作横向变化，axis=0为纵向操作纵向变化，而不是想行和列。
numpy之 copy & deep copy
1.python普通的用变量给另一个变量赋值，实际两个变量占用的一块内存空间，相当于C语言指针、C++别名的概念。
就造成了：如果一个变量值改变了，另一个变量值也会随之而变！，见如下实例：
import numpy as np
a = np.arange(4)
print(a)
b = a
c = a
d = b
a[0] = 11
print(a)
print(b is a)#True
print(c is a)#True
print(d is a)#True
#可见a, b, c, d都是相同的，占用的同一块内存，只是名字不同（别名：大名，小名）
print(b)
print(c)
print(d)
d[1:3] = [22, 33]#赋值下标1~2(不含3)！
print(d)
print(a)
运行结果：
[0 1 2 3]
[11 1 2 3]
True
True
True
[11 1 2 3]
[11 1 2 3]
[11 1 2 3]
[11 22 33 3]
[11 22 33 3]
2.要想赋值不受到影响怎么办？可以用copy() 函数。如下：
import numpy as np
a = np.arange(4)
b = a.copy()#deep copy,相当于又new了一个对象，新开辟了一块内存空间。
print(a)
print(b)
a[3] = 44
print(a)
print(b)#值不改变。
运行结果：
[0 1 2 3]
[0 1 2 3]
[ 0 1 2 44]
[0 1 2 3]
整理重点（+补充+测试）
import numpy as np
import matplotlib.pyplot as plt#图像。下一篇博文会讲
data = np.arange(16).reshape(4, 4)
print(data)
print(data[1:3])
print(data[1:3, 2:4])
print(data[:, 2:4])
print(data > 10)#与10比较，返回矩阵型型的布尔True False
print(data[data > 10])#筛选出大于10，返回一维序列
print(data[data % 2 == 0])#筛选出偶数，返回一维序列
x = np.arange(1, 5).reshape(2, 2)
y = np.arange(5, 9).reshape(2, 2)
print(x)
print(y)
print(x+y)
print(np.add(x, y))
print(x-y)
print(x*y)
print(x.dot(y))
print(x/y)
x = np.array(x, dtype=float)
y = np.array(y, dtype=float)
print(x/y)
print(np.sqrt(x))
print(x.T)
print(np.linspace(1, 10))
print(np.linspace(1, 10, 3))
print(np.linspace(0, 2*np.pi, num = 3))
print(np.linspace(0, 2*np.pi, num = 5))
print(np.linspace(0, np.pi, num = 3))
x = np.linspace(0, 2*np.pi, num = 100)
y = np.sin(x)
print(y)
plt.plot(x, y)#图像。下一篇博文会讲
plt.show()#显示图像。下一篇博文会讲
运行结果：
C:\Python\Anaconda3\python.exe C:/AI/AnacondaProject/2_pandas.py
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[[ 4 5 6 7]
[ 8 9 10 11]]
[[ 6 7]
[10 11]]
[[ 2 3]
[ 6 7]
[10 11]
[14 15]]
[[False False False False]
[False False False False]
[False False False True]
[ True True True True]]
[11 12 13 14 15]
[ 0 2 4 6 8 10 12 14]
[[1 2]
[3 4]]
[[5 6]
[7 8]]
[[ 6 8]
[10 12]]
[[ 6 8]
[10 12]]
[[-4 -4]
[-4 -4]]
[[ 5 12]
[21 32]]
[[19 22]
[43 50]]
[[0.2 0.33333333]
[0.42857143 0.5 ]]
[[0.2 0.33333333]
[0.42857143 0.5 ]]
[[1. 1.41421356]
[1.73205081 2. ]]
[[1. 3.]
[2. 4.]]
[ 1. 1.18367347 1.36734694 1.55102041 1.73469388 1.91836735
2.10204082 2.28571429 2.46938776 2.65306122 2.83673469 3.02040816
3.20408163 3.3877551 3.57142857 3.75510204 3.93877551 4.12244898
4.30612245 4.48979592 4.67346939 4.85714286 5.04081633 5.2244898
5.40816327 5.59183673 5.7755102 5.95918367 6.14285714 6.32653061
6.51020408 6.69387755 6.87755102 7.06122449 7.24489796 7.42857143
7.6122449 7.79591837 7.97959184 8.16326531 8.34693878 8.53061224
8.71428571 8.89795918 9.08163265 9.26530612 9.44897959 9.63265306
9.81632653 10. ]
[ 1. 5.5 10. ]
[0. 3.14159265 6.28318531]
[0. 1.57079633 3.14159265 4.71238898 6.28318531]
[0. 1.57079633 3.14159265]
[ 0.00000000e+00 6.34239197e-02 1.26592454e-01 1.89251244e-01
2.51147987e-01 3.12033446e-01 3.71662456e-01 4.29794912e-01
4.86196736e-01 5.40640817e-01 5.92907929e-01 6.42787610e-01
6.90079011e-01 7.34591709e-01 7.76146464e-01 8.14575952e-01
8.49725430e-01 8.81453363e-01 9.09631995e-01 9.34147860e-01
9.54902241e-01 9.71811568e-01 9.84807753e-01 9.93838464e-01
9.98867339e-01 9.99874128e-01 9.96854776e-01 9.89821442e-01
9.78802446e-01 9.63842159e-01 9.45000819e-01 9.22354294e-01
8.95993774e-01 8.66025404e-01 8.32569855e-01 7.95761841e-01
7.55749574e-01 7.12694171e-01 6.66769001e-01 6.18158986e-01
5.67059864e-01 5.13677392e-01 4.58226522e-01 4.00930535e-01
3.42020143e-01 2.81732557e-01 2.20310533e-01 1.58001396e-01
9.50560433e-02 3.17279335e-02 -3.17279335e-02 -9.50560433e-02
-1.58001396e-01 -2.20310533e-01 -2.81732557e-01 -3.42020143e-01
-4.00930535e-01 -4.58226522e-01 -5.13677392e-01 -5.67059864e-01
-6.18158986e-01 -6.66769001e-01 -7.12694171e-01 -7.55749574e-01
-7.95761841e-01 -8.32569855e-01 -8.66025404e-01 -8.95993774e-01
-9.22354294e-01 -9.45000819e-01 -9.63842159e-01 -9.78802446e-01
-9.89821442e-01 -9.96854776e-01 -9.99874128e-01 -9.98867339e-01
-9.93838464e-01 -9.84807753e-01 -9.71811568e-01 -9.54902241e-01
-9.34147860e-01 -9.09631995e-01 -8.81453363e-01 -8.49725430e-01
-8.14575952e-01 -7.76146464e-01 -7.34591709e-01 -6.90079011e-01
-6.42787610e-01 -5.92907929e-01 -5.40640817e-01 -4.86196736e-01
-4.29794912e-01 -3.71662456e-01 -3.12033446e-01 -2.51147987e-01
-1.89251244e-01 -1.26592454e-01 -6.34239197e-02 -2.44929360e-16]
并生成函数图像：
转载：https://blog.csdn.net/Acegem/article/details/102484140
查看评论