课程目录 小象学院 - 人工智能
关注公众号【Python家庭】领取1024G整套教材、交流群学习、商务合作。整理分享了数套四位数培训机构的教材，现免费分享交流学习，并提供解答、交流群。
你要的白嫖教程，这里可能都有喔~
数据科学武功秘籍—numpy
numpy是Python中的一个基础工具包，主要用于科学计算和数据分析。
在python程序中，如果想使用numpy的话，需要使用import关键字引入numpy：
AI_2_0_1
import numpy如果想查看numpy的版本号，可以使用内置属性__version__获取，注意：属性__version__前后分别是两个短下划线！
AI_2_0_2
import numpy
numpy.__version__为了使用方便，通常会给numpy起一个别名，我们管它叫np，起别名要使用as关键字实现。别名可以随意起，只要你喜欢管它叫“狗蛋”都行，注意不能使用中文别名，要是真想叫“狗蛋”可以用拼音“goudan”^_^
AI_2_0_3
import numpy as np
# 通过别名np调用numpy提供的功能
np.__version__在使用numpy这个工具包的时候，使用最多的当属数组array这种数据存储结构了。
numpy中的数组结构
接下来开始介绍numpy中的数组array。
想使用一个数组来存储数据，首先要创建一个数组。创建数组非常容易，使用numpy内置的array函数就可以直接创建一个数组。
例如，创建一个包含0到9十个数字的数组。
AI_2_0_4
import numpy as np
# 在array函数中直接传入一个列表，即可创建一个数组
nparray = np.array([0,1,2,3,4,5,6,7,8,9])
print(nparray)如果我们想查看一个数组的形状，可以使用数组的shape属性，shape属性的返回结果是一个元组，元组中的每一个元素表示它对应的维度的长度。
我们用一个例子来解释下shape属性的使用方法。
AI_2_0_5
import numpy as np
# 在array函数中直接传入一个列表，即可创建一个数组
nparray = np.array([0,1,2,3,4,5,6,7,8,9])
print(nparray.shape)从上面的运行结果可以看出，nparray的shape属性返回的元组包含一个元素10，表示这是一个一维数组，第一维有10个元素。更多维度的数组，我们会在后面的课程内容中介绍，先不要着急，我们慢慢学。
如果想查看数组中的某个元素，可以通过这个元素在数组中的位置查看其值，元素在数组中的位置使用数字下标表示，注意下标从0开始。
AI_2_0_6
import numpy as np
# 在array函数中直接传入一个列表，即可创建一个数组
nparray = np.array([0,1,2,3,4,5,6,7,8,9])
nparray[3] # 查看nparray中的第4个元素通过下标修改某个元素的值
AI_2_0_7
import numpy as np
# 在array函数中直接传入一个列表，即可创建一个数组
nparray = np.array([0,1,2,3,4,5,6,7,8,9])
nparray[3] = 200 # 将第4个元素的值修改为200
print(nparray)注意：numpy中的array不允许向数组中添加不同类型的元素，array中只能存储相同类型的元素
下面尝试将nparray第4个元素的值由整数200修改成字符串xiaoxiangxueyuan，程序将会抛出“ValueError"错误！
AI_2_0_8
import numpy as np
# 在array函数中直接传入一个列表，即可创建一个数组
nparray = np.array([0,1,2,3,4,5,6,7,8,9])
nparray[3] = "xiaoxiangxueyuan"如果想窥探array中存储的数据类型，可以使用array提供的dtype属性。
AI_2_0_9
import numpy as np
# 在array函数中直接传入一个列表，即可创建一个数组
nparray = np.array([0,1,2,3,4,5,6,7,8,9])
nparray.dtype # 通过dtype得知nparray里存储的元素类型是64位整型除了向array函数中传入一个列表的方式创建数组外，numpy还提供了其他很多创建数组的方法，下面我们来介绍一下。
创建全0数组
1. 使用zeros(num)函数创建一个全零数组，zeros函数需要传入一个数字参数num，num表示数组中有几个0，也就是元素个数。
AI_2_0_10
import numpy as np
# 创建一个包含10个0的数组
zero_array = np.zeros(10)
print(zero_array) #打印数组里的所以元素
print(zero_array.dtype) #打印数组中元素类型使用zeros函数创建数组，数组里的元素默认是float64浮点型。如果想设置数据中的元素为其他类型，可以在zeros函数中传入“dtype=类型”。
AI_2_0_11
import numpy as np
# 创建一个包含10个整数0的数组
zero_array = np.zeros(10,dtype=int)
print(zero_array)
print(zero_array.dtype)zeros函数传入的第一个参数是一个数字（这个数字表示数组的大小），创建出来的数组只有一行数据，我们称这样的数组为一维数组，或者是行向量。向量是一个数学概念，在机器学习中经常会用到很多数学公式，所以在后面的学习中，只要提到行向量就是指一维数组。
例如，全零一维数组（向量）：[0 0 0 0 0 0 0 0 0 0]
zeros函数的第一个参数除了可以是一个数字之外，还可以是一个元组，用于创建多维数组，我们以创建二维数组为例。
AI_2_0_12
import numpy as np
# 创建一个3行5列的全零二维数组
zeros_2 = np.zeros((3,5))
print(zeros_2)我们使用shape属性查看下刚才创建的全零二维数组的形状。
AI_2_0_13
import numpy as np
# 创建一个3行5列的全零二维数组
zeros_2 = np.zeros((3,5))
print(zeros_2.shape)通过shape属性返回的元组中有两个元素，就表示zeros_2是一个二维数组，元组的第1个元素表示第一维的长度是3，也就是3行；元组的第2个元素表示第二维的长度是5，也就是有5列。 我们又发现一个规律：一个数组的shape属性返回的元组的元素个数就等于这个数组的维度。有了这个规律，就不用去掰手指数数组的中括号个数了。
np.zeros((3,5)) 是np.zeros(shape=(3,5))的省略写法，两种方式相同，shape参数用于设置数组的形状，可以省略参数名直接传入参数值。
AI_2_0_14
import numpy as np
# 创建一个3行5列的全零二维数组，并且元素类型是整型
np.zeros(shape=(3,5), dtype=int)array([[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]])可能你对如何判断一个数组的形状还不是很清楚，我教你一个小窍门，判断一个数组是几维数组，就数它最开始有几个左中括号。 例如，上面我们创建的3行5列的二维数组，从左数有两个左中括号，那它就是二维数组。 [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
我们前面提到的一维数组也被称为行向量，二维数组也被称为矩阵。
创建全1数组
2. 在机器学习中，还会经常用到的一种数组是全1数组，跟全零数组的原理一样，只是数组中的元素从0变成了1。
创建全1数组，使用numpy提供的ones函数，这个函数的使用方法跟zeros函数的使用方法一模一样。
AI_2_0_15
import numpy as np
# 创建一个包含10个1的全1数组，这是个一维数组（向量）
np.ones(10)array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])AI_2_0_16
import numpy as np
# 创建一个3行5列的二维全1数组，这是个二维数组
np.ones((3,5),dtype=int)array([[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]])经过上面的学习，可能你会问：全1或者全0的数组有什么用呢？
目前来看，它们没啥用，只是装着不同数值的数组，等到后面我们根据机器学习算法原理，实现一个属于我们自己的机器学习算法的时候就会用到。比如我要对一系列的参数设置一个初始值，初始值都是0，这时候全0数组就派上用场了。
创建全num数组
3.上面讲到的全0数组和全1数组都有专门的函数直接生成，如果我要生成一个全2、全3、全5...数组该怎么实现呢？
不用担心，numpy为我们提供了full函数，你可以用full函数自定义包含任何数字的全xx数组。
使用full函数语法：full(数组形状,填充的数字)，函数的第一个参数数组的形状，一般要传入一个元组来表示数组的形状。
说这么多不如看个例子理解起来更直观！
例1：创建一个全2的一维数组，数组的大小是10。 如果使用full函数创建一个一维数组，那么full函数的语法是：full(数组大小,填充的数字)
AI_2_0_17
import numpy as np
# full函数的两个参数：
# 第1个参数表示数组的形状，用一个元组来表示
# 第2个参数表示填充到数组中的元素的值
# 注意：一个包含1个元素的元组(10,)的表示方法就是在元素后边加个逗号
np.full((10,),2)array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2])np.full((3,9),666)array([[666, 666, 666, 666, 666, 666, 666, 666, 666],
[666, 666, 666, 666, 666, 666, 666, 666, 666],
[666, 666, 666, 666, 666, 666, 666, 666, 666]])对于使用full函数创建的一维数组，传入的第一个表示数组形状的参数可以不是元组，可以直接传入一个表示数组中元素个数的数字。
AI_2_0_18
import numpy as np
np.full(10,2)array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2])np.full(10,2)array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2])np.full([6,6],9)array([[9, 9, 9, 9, 9, 9],
[9, 9, 9, 9, 9, 9],
[9, 9, 9, 9, 9, 9],
[9, 9, 9, 9, 9, 9],
[9, 9, 9, 9, 9, 9],
[9, 9, 9, 9, 9, 9]])例2：创建一个全2的二维数组，数组的形状是2行3列。
AI_2_0_19
import numpy as np
# full函数的两个参数：
# 第1个参数表示数组的形状，用一个元组来表示，例：2行3列用元组表示是(2,3)
# 第2个参数表示数组中要填充的数字
np.full((2,3),2)array([[2, 2, 2],
[2, 2, 2]])np.full((2,3),2)array([[2, 2, 2],
[2, 2, 2]])arange函数创建数组
4. 如果我想在一个指定的区间范围内，快速创建一个数组，而且我不想自己写循环往数组里一个一个填数据，有没有什么简便的方法呢？
numpy这么强大，当然可以满足这样的小需求。numpy提供了arange函数可以在指定的区间范围内，快速地生成一个数组，并且按照指定的步长自动填入数据。
听着好像很厉害的样子，让我们来动手试试！
AI_2_0_20
import numpy as np
# 在[0,20)区间内（注意是左闭右开区间，不包含末尾的20），创建一个数组，数组中两个挨着的元素差值是1
# 也就是在[0,20)区间内创建一个数组，并且包含20个整数
np.arange(0,20)array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19])np.arange(18,39)array([18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38])我们只需要一行代码就实现了这么复杂的需求，numpy太厉害啦！
从上面的运行结果可以看出，使用arange创建数组的时候，没有设置数组内元素之间的差值是1，但是数组中相邻两个元素之前的差值正好是1。
原因是arange函数默认使用的步长是1，也就是默认情况下，使用arange创建的数组内相邻的两个元素之间的差值是1。
我们也可以自定义arange的步长大小，向arange函数传入第3个参数就可以设置步长。
arange函数中的参数介绍：
-
第1个参数：开始值，包含；
-
第2个参数：结束值，不包含；
-
第3个参数：步长，默认值1。
AI_2_0_21
import numpy as np
# 创建一个数组，包含1到20区间内的所有奇数
np.arange(1,20,2) # 从1开始，步长为2array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19])np.arange(18,39,3)array([18, 21, 24, 27, 30, 33, 36])np.arange(6,666,66)我们还可以在调用arange函数的时候只传入一个数字num，这时候就会生成一个一维数组，数组里的元素默认是在[0,num)区间内，相邻两个元素之间的差值是1，也就是使用默认步长生成的数组元素，看个例子就明白了。
AI_2_0_22
import numpy as np
# 创建一个数组，在区间[0,20)内，步长为1
np.arange(20)array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19])np.arange(18)array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17])我们已经学习了4种创建数组的方法：array[列表]、zeros全零数组、ones全1数组、arange指定区间内创建数组，掌握了这4种创建数组的方法基本上就可以自封为“数组小王子”啦^_^
randint随机数数组
接下来我要讲的一个知识点是随机数，随机数在我们的生活中经常使用，比如公司年会抽奖，在所有的员工中随机抽取一个幸运的员工获得年终大奖，为了保证公平公正，程序员小哥哥就要写个随机数程序，从全体员工中随机挑选一个员工。
是不是你也想当那个被抽中的幸运员工？那让我们来学习下生成随机数背后的方法吧。
numpy中有个专门模块用于处理随机数相关的操作，它就是random模块，random模块已经给我们实现好了一些生成随机数的函数，接下来我们学习几个常用的生成随机数的函数。
在一个区间内生成整数随机数，实现这个需求要使用random模块的randint函数。
AI_2_0_23
import numpy as np
# 在[0,10)之间生成一个整数随机数
# 注意：产生的随机数区间是左闭右开区间，不包含结尾的数字10，也就是randint函数生成的随机数永远不会有10出现
np.random.randint(18,39,(2,7))array([[29, 24, 24, 18, 27, 31, 27],
[19, 22, 36, 36, 30, 28, 25]])randint还可以传入第3个参数size，用于设置生成的随机数个数。 如果将size设置成一个整数，那么返回的是一个一维数组（向量）。 如果将size设置成一个元组，那么返回的是一个多维数组（矩阵）。
AI_2_0_24
import numpy as np
# 在[0,10)之间生成5个随机数
np.random.randint(0,10,(6,6))array([[2, 5, 2, 0, 9, 8],
[9, 7, 4, 7, 3, 0],
[9, 2, 7, 1, 1, 5],
[5, 3, 4, 2, 9, 7],
[1, 6, 8, 7, 2, 7],
[9, 6, 3, 6, 2, 7]])AI_2_0_25
import numpy as np
# 生成一个3行5列的二维矩阵，每一行里的5个元素都是[0,10)之间的随机数
np.random.randint(0,10,size=(3,5))array([[7, 3, 5, 0, 5],
[1, 2, 6, 9, 4],
[4, 3, 9, 6, 7]])第三个参数的参数名称size可以省略，我是建议不要省略，因为带着参数名，代码的可读性更强。
AI_2_0_26
import numpy as np
# 在[0,10)之间生成5个随机数
np.random.randint(0,10,5)array([9, 0, 5, 0, 1])怎么生成随机数我们已经掌握了，现在又有了一个新的需求，老板要求每次生成的随机数相同。
你听到这个需求可能心里在嘀咕，既然是随机数，怎么可能每次生成的随机数都相同呢？难道年会抽奖有内幕？
老板的这个需求非常容易实现，numpy的random模块给我们提供了一个叫做随机种子的函数seed，在使用seed函数的时候需要传入一个数字，这个数字可以随意传，我们可以把这个数字理解成种子“编号”，这样就能够保证使用同一个“编号”的种子生成的随机数是相同的。
接下来我们做个对比测试，通过观察测试结果可以非常清楚的明白seed随机种子函数的使用。
AI_2_0_27
import numpy as np
np.random.seed(111)
print("使用111种子生成的随机向量：", np.random.randint(0,10,5))
np.random.seed(111)
print("使用111种子生成的随机向量：", np.random.randint(0,10,5))
np.random.seed(21)
print("使用21种子生成的随机向量：", np.random.randint(0,10,5))使用111种子生成的随机向量： [4 4 4 6 3]
使用111种子生成的随机向量： [4 4 4 6 3]
使用21种子生成的随机向量： [9 8 4 0 0]通过上面的对比测试结果可以看出，两次使用相同随机种子111生成的随机向量里的数字是相同的。
reshape改变数组形状
之前我们将讲解过，通过数组的shape属性可以查看数组的形状，如果想改变数组的形状可以使用reshape函数，我们来看看reshape函数具体怎么来使用。
AI_2_0_28
import numpy as np
# 创建一个包含6个数字的一维数组
x1 = np.random.randint(0,10,6)
print("x1 shape :", x1.shape)
print(x1)
# 将数组x1转换成一个2行3列的二维数组
x2 = x1.reshape(2,3)
print("-------------------------") #打印一个分割线，只为了方便看打印结果
print("x1 shape :", x1.shape)
print(x1)
print("x2 shape :", x2.shape)
print(x2)x1 shape : (6,)
[9 7 0 8 1 3]
-------------------------
x1 shape : (6,)
[9 7 0 8 1 3]
x2 shape : (2, 3)
[[9 7 0]
[8 1 3]]
从运行结果看：
x1.shape返回的是一个包含1个元素的元组，表示x1是一个一维数组，数组里有6个元素。
x2.shape返回的是一个包含2个元素的元组，表示x2是一个两行三列的二维数组，x2是使用reshape函数在x1的基础上转换得到的新数组，原数组x1没有发生改变。
使用reshape函数改变数组形状生成一个新的数组的时候，原数组中的元素个数要正好填满新数组，例如，数组x1有6个元素，数组x2的形状是2行3列，要想填满数组x2就必须有6个元素，正好x1有6个元素，所以使用reshape转换数组形状能成功。
接下来我们用两个错误的例子来验证下上面的说法。
AI_2_0_29
import numpy as np
# 创建一个包含6个数字的一维数组
x1 = np.random.randint(0,10,6)
# 错误例子1，x1的元素个数不够填满新的数组
x4 = x1.reshape(3,4)ValueError Traceback (most recent call last)
<ipython-input-1-dc89431fa186> in <module>
5
6 # 错误例子1，x1的元素个数不够填满新的数组AI_2_0_30
import numpy as np
# 创建一个包含6个数字的一维数组
x1 = np.random.randint(0,10,6)
# 错误例子2，x1的元素个数超过了新数组需要的元素个数
x5 = x1.reshape(2,2)ValueError Traceback (most recent call last)
<ipython-input-1-4a34360b3f91> in <module>
5
6 # 错误例子2，x1的元素个数超过了新数组需要的元素个数在使用reshape的时候，如果你不关心转换之后有多少行或者有多少列，应该怎么操作呢？下面我用几个例子来演示下reshape的新用法。
需求1：x1是一个包含6个元素的一维数组，现在我基于x1使用reshape转换生成一个新数组，我要求新数组只要有2行就行，具体有几列我不关心
AI_2_0_31
import numpy as np
# 创建一个包含6个数字的一维数组
x1 = np.random.randint(0,10,6)
x1.reshape(2,-1)array([[4, 2, 9],
[0, 7, 7]])从这个需求的代码实现可以看出，在使用reshape的时候，不关心的维度可以使用-1表示，让机器自动去判断。
需求2：x1是一个包含6个元素的一维数组，现在我基于x1使用reshape转换生成一个新数组，我要求新数组只要有2列就行，具体有几行我不关心
AI_2_0_32
import numpy as np
# 创建一个包含6个数字的一维数组
x1 = np.random.randint(0,10,6)
x1.reshape(-1,6)array([[6, 6, 6, 7, 7, 6]])通过这个需求，再一次验证了上一个需求的结论，我不关心有多少行，那么控制行的参数就传-1，让机器自己去判断转换之后的新数组有多少行。
我们在前面学习了使用数组的shape属性可以查看数组的形状，除了shape属性之外，还有两个比较常用的属性，分别是查看数组维度的ndim属性和查看数组元素个数的size属性。
ndim和size这两个属性比较容易理解，我直接用例子来说明。
AI_2_0_33
import numpy as np
# 创建一个包含6个数字的一维数组
x1 = np.random.randint(0,10,6)
x6 = np.random.randint(0,10,6)
print("x6是{}维数组".format(x6.ndim))
print("x6中有{}个元素".format(x6.size))
x7 = x6.reshape((3,2))
print("x7是{}维数组".format(x7.ndim))
print("x7中有{}个元素".format(x7.size))数组切片
我们在前面学习了通过数组下标获取数组的某个元素，这种方式只能获取一个元素，如果想获取数组中的一批元素或者一个片段的元素应该怎么操作呢？
numpy为我们提供了好用到爆的切片功能，老规矩直接上例子代码。
AI_2_0_34
import numpy as np
# 创建一个一维数组：[0 1 2 3 4 5 6 7 8 9]
arr1 = np.arange(10)
print(arr1)需求1：获取arr1的前5个元素
AI_2_0_35
import numpy as np
# 创建一个一维数组：[0 1 2 3 4 5 6 7 8 9]
arr1 = np.arange(10)
arr1[:5]array([0, 1, 2, 3, 4])我们只用了一行代码就完成了获取arr1的前5个元素的需求，通过这行代码我们也看出了切片的语法：数组名[开始下标:结束下标]
切片的语法有两个注意点： 1）如果切片是从第一个下标0开始，可以不写开始下标； 2）切片不包含结束下标对应的数组元素；
需求2：获取arr1的后3个元素
AI_2_0_36
import numpy as np
# 创建一个一维数组：[0 1 2 3 4 5 6 7 8 9]
arr1 = np.arange(10)
arr1[-3:]array([7, 8, 9])数组的下标从0开始，数组arr1中共有10个元素，arr1最后一个元素的脚标是9，要完成需求是获取arr1的后3个元素，那么脚标就是从7开始。
实现这个需求有个注意点：切片的结束下标如果不写的话，表示切片到数组的结尾。
需求3：获取arr1的第3个到第6个元素
AI_2_0_37
import numpy as np
# 创建一个一维数组：[0 1 2 3 4 5 6 7 8 9]
arr1 = np.arange(10)
arr1[2:6]array([2, 3, 4, 5])数组的下标从0开始，第3个元素的下标是2，第6个元素的下标是5，要获取到第6个元素，也就是说切片的结果要包含第6个元素，由于切片是不包含结束下标对应的元素的，所以切片的结束下标要设置成第6个元素后一个下标的位置。
解释这么多！弄得这么绕！全怪数组的下标从0开始！
需求4：从数组arr1中，隔一个元素获取一个
小样儿还想难倒我！给我提这么刁钻的需求！你是不是不知道切片可以设置步长，看我通过切片的步长一行代码给你搞定。
小提示：切片带步长的语法是：数组名[开始下标:结束下标:步长]
AI_2_0_38
import numpy as np
# 创建一个一维数组：[0 1 2 3 4 5 6 7 8 9]
arr1 = np.arange(10)
arr1[::2]因为是要从头取到尾，默认切片不设置开始和结束下标就表示从第1个元素到最后1个，上面的代码等价于设置开始和结束下标的方式：arr1[0:10:2]
由于需求是隔一个元素获取一个，中间要跳过一个元素，所以要设置步长为2。
需求5：从后向前获取数组arr1中的元素，相当于把数组arr1翻过来
AI_2_0_39
import numpy as np
# 创建一个一维数组：[0 1 2 3 4 5 6 7 8 9]
arr1 = np.arange(10)
arr1[::-1]array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])步长是正数表示从左向右获取，步长是负数表示从右向左获取。需求是把数组翻过来，那就是从右向左获取，而且要获取原数组arr1的所有元素，所以步长设置为-1。
上面的5个需求的实现方法能够全部掌握了，基本上可以熟练地使用数组切片了。
切片不是一维数组的特有功能，多维数组同样可以使用切片，接下来我们以最常用的二维数组为例，讲解在二维数组中是如何使用切片的。
AI_2_0_40
import numpy as np
# 先创建一个3行5列的二维数组
arr2 = np.arange(15).reshape((3,5))
print(arr2)
print("arr2是{}维数组".format(arr2.ndim))
print("arr2有{}个元素".format(arr2.size))[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
arr2是2维数组
arr2有15个元素
新需求1：获取数组arr2的前2行的前3列
AI_2_0_41
import numpy as np
# 先创建一个3行5列的二维数组
arr2 = np.arange(15).reshape((3,5))
arr2[:2,:3]二维数组的切片语法：数组[第一维开始下标:第一维结束下标,第二维开始下标:第二维结束下标]
我们从二维数组的切片语法可以看出中括号内以逗号分隔，逗号前的开始/结束下标控制第一维切片，逗号后的开始/结束下标控制第二维。其他切片相关的语法规则跟前面一维数组的规则一样。
需求是先获取arr2的前2行，通过切片中设置第一维的开始/结束下标控制；然后再获取前两行的前三列，通过切片中设置第二维的开始/结束下标控制。
新需求2：隔一行取一行，再隔一列取一列
AI_2_0_42
import numpy as np
# 先创建一个3行5列的二维数组
arr2 = np.arange(15).reshape((3,5))
arr2[::2,::2]通过这个需求的实现，我们可以得出一个结论，使用数组切片的时候，不管数组有多少维，每一个维度的切片都是使用相同语法规则的切片表达式控制。
通过本关内容的学习我们的基本功已经练习的足够扎实，本关的内容没有太大的难度，主要是多练习，孰能生巧。
本关我们先到这里，拜拜~
联系我们，一起学Python吧
分享Python实战代码，入门资料，进阶资料，基础语法，爬虫，数据分析，web网站，机器学习，深度学习等等。
关注公众号「Python家庭」领取1024G整套教材、交流群学习、商务合作