Numpy入门基础(二)

前言

hi，各位好，欢迎来到鲨鱼🦈的数据科学笔记，前面我们说到Numpy的数组创建的知识第一部分，接下来我们来深入介绍ndarry方面的操作，闲话少叙，让我们开始吧。

ndarray的读写操作

我们写代码的目的是无非是通过程序让计算机去做我们所要求的事，而在通过代码构建这些需求的过程中离不开“增删改查”四项操作，无论是做代码开发还是数据库的操作都是根据它们的原理进行技术实现的。
而在Numpy的ndarry数组当中也可以进行“增删改查”操作，我们可以通过这些操作对ndarry数组进行改造从而达成自身的运算需求。

索引访问

在之前的学习我们知道ndarry和列表的性质类似，因此我们也可以在ndarry数组当中使用类似的方法进行索引访问：

import numpy as np

l1 = [1,2,3,4,5,6]
l2 = [[1,2,3],[4,5,6]]

print(l1[0],l1[-1])
# 1,6

print(l2[1][1])
# 5

arr1 = np.random.randint(0,10,size=10)
display(arr1)
# array([7, 0, 9, 9, 0, 5, 4, 5, 1, 9])

print(arr[2],arr[-2])
# 7,9

在面对高维数组的时候我们可以使用索引进行直接访问和间接访问。直接访问是指通过索引值或切片来获取ndarray中的元素；间接访问是指通过另一个数组作为索引来获取ndarray中的元素。
我们首先来看直接访问的示例

arr2 = np.random.randint(0,10,size=(3,3))
display(arr2)

"""
array([[3, 2, 4],
       [7, 0, 3],
       [9, 4, 8]])
"""
print(arr2[2,1])
# 4

print(arr2[2][1])
# 4

从上面我们可以看到，我们创建了一个二维数组 arr2，然后使用arr2[2][1]和arr2[2,1]的方式直接访问数组中的元素，最终输出结果都为4，不过在实际的开发当中推荐使用逗号分隔的方式arr2[2,1]进行元素的访问，这样更快捷。
当然，我们也可以使用直接访问的索引方式进行对ndarry的数组进行元素修改，例如：

arr2[2][1]=100
display(arr2)
"""
array([[3, 2, 4],
       [7, 0, 3],
       [9, 100, 8]])
"""


arr2[2,1]=100
display(arr2)

"""
array([[3, 2, 4],
       [7, 0, 3],
       [9, 100, 8]])
"""

列表访问

在ndarry当中我们可以使用列表的形式进行数组访问，设置一个列表作为一个索引列，然后ndarry会读取列表中的值作为索引下标并返回对应下标元素的值，例如

import numpy as np
arr1 = np.random.randint([0,100,size])
display(arr1)
# array([69, 38, 95, 43, 79, 90,  6, 64, 36, 25])

index = [1,2]
display(arr1[index])
# array([38,95])

index1 = [1,3,5,1,3,5]
display(arr1[index1])
# array([38, 43, 90, 38, 43, 90])

同时ndarry也可以作为ndarray对象索引的列表：

index2 = np.random.permutaion(5)
# 使用permutaion随机生成5个数，从而打乱原数组的排序

display(arr1[index2])
# array([95, 38, 69, 43, 79])

random_index = np.random.permutaion(10)[[0,1,2]]

display(random_index)
# array([1, 5, 8])

display(arr1[random_index])
# array([38, 90, 36])

random_index2 = np.random.randint(0,10,size=3)
display(random_index2)
# array([0, 9, 2])

display(arr1[random_index2])
# array([69, 25, 95])

bool列表访问

在上面当中除了使用列表中得数值索引进行下标访问外，还可以通过在列表当中的bool值进行访问。我们都知道bool值的形式是True和False也就是1和0，当用全为bool列表作为索引进行访问的时候，当Ture则提取为Ture作为下标的值，当为False时则不会进行访问，具体情况如下：

arr2 = np.array(0,100,size=(5,))
display(arr2)
# array([37, 45, 92, 25, 34])

bool_index = [True,False,False,True,False]
display(arr2[bool_index])
# array([37, 25])

如果要在高维数组中使用，要记得指定其raws和clomuns也就是其行和列，一般来说其形式为这样arr[raws,cloumns]，例如想获取数组arr2的第一行和第二行的全部元素我们可以这样做：

arr3 = np.random.randint(0,100,size=(5,5))
display(arr3)
"""
array([[88, 49, 69,  2, 16],
       [57, 14, 26, 52, 63],
       [61, 77, 18, 54, 34],
       [31, 47, 37, 71, 91],
       [69, 41, 78, 65, 68]])
"""
display(arr3[[0,1]])
"""
array([[88, 49, 69,  2, 16],
       [57, 14, 26, 52, 63]])
"""

如果想要获得第一列和第二列的全部元素，我们必须在行参数中添加冒号作为行索引代表获取第一、第二列行的全部元素，后面列参数再填获取元素的索引，例如：

display(arr2[:[1,2]])
"""
array([[88, 49],
       [57, 14],
       [61, 77],
       [31, 47],
       [69, 41]])
"""

切片访问

在学习了上面的列表访问高维数组获取指定的的元素后，这时候有人会说了，你这高维数组的列表访问都只能获取一行或者一列的全部元素，如果我想获得某几行或者某几列的元素时应该怎么做，我知道你很急，但你先别急(¬､¬) (￢_￢)，接下来说的切片访问就能解决上面的问题。嘿嘿，想不到把ndarry也能使用切片进行访问吧，是不是觉得ndarry和列表挺像的๑乛◡乛๑ (●′∀｀●)。
ndarry采用切片访问的方式和列表非常相似，都是采用arry[start:end:step]的方式获取元素，其中start为起始值，end为终止值，step为其步长一般默认为1,但其取值区间是左闭右开的形式，左边的终止值一般不取，例如：

import numpy as np
arr1 = np.random.randint(0,10,size=5)
display(arr1)
# array([5, 5, 4, 3, 3])

# 取arr1中前3个值
display(arr1[0:3])

也可以通过负数倒着取，不过注意负数取值是从末尾值开始取的，且是从-1开始算起而不是从0开始算的，这里我们想用负数的方式从正序的第三个元素4取到最后一个元素3可以这么做：

display(arr1[-3:])
# array([4, 3, 3])

因为我们是倒着取的所以-1就是最后一个元素3，-2就是倒数第二个元素3，而-3自然就是4了，由于没有设置终止值，自然冒号后面取的就是4后面的所有元素所以最后的结果是array([4,3,3])。
除了能够正着取我们还可以倒着取，方式和列表是一样的，例如我们想让arr1从最后一个元素3开始输出，可以这么做：

display(arr1[::-1])
# array([3, 3, 4, 5, 5])

display(-1::-1)
#array([3, 3, 4, 5, 5])

第一种方式我们没有设置起始值和结束值，而是设置了步长为-1，这代表我们取所有的值并倒着取，第二种方式和一种方式大同小异只不过设置了起始值-1。
说到步长，我们知道其作用就是指在序列或范围中从一个元素到下一个元素的距离或间隔，其形象很像我们在高中所学习到的等差数列的固定差值，例如设置的step=2，就是每隔两个元素获取一个元素：

arr2=np.random.randint(0,100,size=10)
display(arr2)
# array([ 3, 85, 47,  1, 56, 67, 77, 68, 40, 98])

display(arr2[0:-1:2])
# array([ 3, 47, 56, 77, 40])

而在我们之前提到高维数组中获取指定方式的切片我们可以这么做：

arr3 = array([[88, 49, 69,  2, 16],
              [57, 14, 26, 52, 63],
              [61, 77, 18, 54, 34],
              [31, 47, 37, 71, 91],
              [69, 41, 78, 65, 68]])

display(arr3[:2,:2])
"""
array([[88, 49],
       [57, 14]])
"""

这段代码的意思是取第 0 行至第 1 行（不包括第 2 行），以及每行的第 0 列至第 1 列（不包括第 2 列）。通过切片的方式我们就可以取到高维数组的指定内容。

学习了关于如今访问数组的方法后，不如做几道题来巩固一下吧：

1. 构建一个长度为10的随机数组，进行逆序输出
2. 构造一个形状为(5,4)的二维数组，提取最后两列，使用3种方法
3. 构建一个6行5列的数组，对数组进行行方向的随机排序

建议自己思考以后再看答案喔！
第一题

data = np.random.random(size=10)
dispplay(data)
display(data[::-1])

"""
array([0.72888464, 0.48172442, 0.46580419, 0.71868106, 0.35765977,
       0.91799413, 0.14526069, 0.58848584, 0.27973132, 0.00547153])
"""
"""
array([0.00547153, 0.27973132, 0.58848584, 0.14526069, 0.91799413,
       0.35765977, 0.71868106, 0.46580419, 0.48172442, 0.72888464])
"""

第二题

data2 = np.random.randint(0, 100, size=(5,4))
display(data2)
"""
array([[ 5, 56, 19,  5],
       [90,  9, 42, 19],
       [45, 35, 72, 57],
       [75, 51, 10,  8],
       [35,  7, 59,  6]])
"""

# 第一种方法
display(data2[:,[-2,-1]])
"""
array([[19,  5],
       [42, 19],
       [72, 57],
       [10,  8],
       [59,  6]])
"""

#第二种方法
display(data2[:,-2:])
"""
array([[19,  5],
       [42, 19],
       [72, 57],
       [10,  8],
       [59,  6]])
"""

#第三种方法
display(data2[:,[False:False:False:True:True]])
"""
array([[19,  5],
       [42, 19],
       [72, 57],
       [10,  8],
       [59,  6]])
"""

级联和切分

在Numpy中，级联和切分是一项重要的操作，通过其能够把ndarry数组进行构造新的数据项，从而做出更多的数据操作和实验。

级联

concatenate

级联顾名思义就是把两个或者多个数据整合一起，构建成一个新的数据。而在Numpy中，通常指的是将两个或多个数组沿指定方向进行连接操作，Numpy的routines函数里提供了concatenate函数实现数组的级联操作。

import numpy as np

a1 = np.random.randint(0,10,size=(3,4))
a2 = np.random.randint(10,20,size=(3,4))

display(a1,a2)
"""
array([[1, 5, 2, 4],
       [1, 5, 6, 1],
       [0, 6, 6, 6]])
array([[16, 18, 16, 16],
       [17, 14, 19, 19],
       [14, 16, 15, 10]])
"""

#axis=0按列方向进行级联
np.concate((a1,a2),axis=0)

"""
array([[ 1,  5,  2,  4],
       [ 1,  5,  6,  1],
       [ 0,  6,  6,  6],
       [16, 18, 16, 16],
       [17, 14, 19, 19],
       [14, 16, 15, 10]])
"""

级联注意事项：

• 级联的参数是列表，一定要加中括号和小括号
• 维度必须相同
• 形状相同
• 级联的方向默认是shape这个tuple的第一个值所代表的唯独方向
• 可通过axis参数改变级联的方向

a3 = np.random.randint(30,40,size=(3,))
display(a3)

# array([23, 23, 21])

display(a1.ndim)
# 2 

np.concate(a1,a3)
"""
ValueError: all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 1 dimension(s)
"""

我们可以看到上面的ndarry数组进行级联的时候发生了错误，上面报错的大致意思是：在进行级联的时候，输入数组的维度不匹配，并且特别强调了all the input arrays must have same number of dimensions指的是所有输入的数组必须具有相同的维度数量，我们级联的数组a1为2维数组，而a3为1维数组，当进行级联的时候都不在同一个维度上怎么进行处理？那自然是导致报错了啊，就像二次元无法接触三次元一样，二次元在维度结构上只有面而三次元上除了面的结构上还有“层次”(layer)的结构，当三次元的物体接触到二次元的时候那结果肯定就是gg了啊，毕竟维度都不同，除非进行“降维”(Dimensionality reduction)操作，这个之后我们会提及。

a4 = np.random.randint(30,40,size =(3,3))
display(a4,a1)

"""
array([[33, 31, 39],
       [32, 30, 30],
       [39, 37, 34]])
array([[1, 5, 2, 4],
       [1, 5, 6, 1],
       [0, 6, 6, 6]])
"""

display(a1.nidm)

np.concatenate((a1, a4))
"""
all the input array dimensions except for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 4 and the array at index 1 has size 3
"""

从上面我们看到了a4和a1都是相同维度数组，都属于二维数组，可进行级联的时候为什么会报错了呢？这时候我们可以看下报错信息说了什么，通过阅读报错信息我们知道了报错原因，原来是数组的形状不同，报错信息第一段all the input array dimensions except for the concatenation axis must match exactly数组在级联的维度上，必须长度一致，也就是形状相同。
在concatenate中的axis用于指定要沿着哪个轴进行数组拼接，其默认值为axis=0，当axis=0表示沿着纵轴方向拼接数组，也就是将它们上下拼接；axis=1时表示沿着横轴方向进行数组的拼接，也就是将它们进行左右级联。从上面我们可以看到a1的形状为34，a2的形状为33，当我们按照默认axis=0的纵轴方向进行级联，形状明显不对，就导致报错。但是如果我们改变axis的位置，也就是axis=1的时候，就会成功，原因是在横轴方向上两组组数组的形状都是相同的，可以理解为它们都拼接在一条直线上了，效果如下：

np.concatenate((a1, a4), axis=1)

"""
array([[ 1,  5,  2,  4, 33, 31, 39],
       [ 1,  5,  6,  1, 32, 30, 30],
       [ 0,  6,  6,  6, 39, 37, 34]])
"""

上诉我们说的都是二维数组方面的级联知识，但concatenate的级联功能十分强大，不仅可以进行多个数组的级联，而且还支持三维以及高维数组的级联，但由于我们这里主要说的是Numpy基础入门，所以说的都是一些比较基础的东西，在前期学习中二维数组比较入门理解，三维数组以及更高维的数组的知识也是在二维数组的基础上进行衍生，有些高维数组方面的操作可能留到后面来说明（咕咕咕） ≖‿≖✧ o‿≖✧(๑•̀ㅂ•́) ✧。

vstack和hstack

vstack和hstack是Numpy中用于数组之间进行垂直和水平方向堆叠操作的routines函数，它们用于将多个数组按照指定的方向进行组合，并返回一个新的数组。

v是vertical的简写表示纵向
h是horizeontal的简写表示横向

• vstack函数用于垂直方向（沿着行方向）堆叠数组，它接受一个元组，列表或数组作为参数，将它们按照行的方向进行堆叠在一起，并返回结果数组。被堆叠的数组必须具有相同的列数。

import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.vstack((a,b))
display(c)

"""
array([[1,2,3],
	   [4,5,6]])
"""

a1 = np.random.randint(0,100,(3,2))
a2 = np.random.randint(0,100,(3,2))
diplay(a1,a2)
"""
array([[62, 98,  5],
       [77, 38, 59]])
array([[50,  3, 84],
       [ 7, 57,  0]])
"""

a3 = np.vstack((a1,a2))
display(a3)
"""
array([[62, 98,  5],
       [77, 38, 59],
       [50,  3, 84],
       [ 7, 57,  0]])
"""

• hstack函数用于在水平方向（沿着列方向）堆叠数组，和vstack一样它也接受一个元组，列表或数组作为参数传入，它们按照列的方向进行堆叠在一起再返回结果数组。被堆叠的数组必须具有相同的列数加粗样式。

import numpy as np
a = np.array([4,5,6])
b = np.array([7,8,9])
c = np.hstack((a,b))
display(c)

"""
array([[4,5,6],
	   [7,8,9]])
"""

a1 = array([[1, 5, 2, 4],
       		[1, 5, 6, 1],
       		[0, 6, 6, 6]])
a4 = array([[33, 31, 39],
       		[32, 30, 30],
       		[39, 37, 34]])

a5 = np.hstack((a1,a4))
display(a5)
"""
array([[ 1,  5,  2,  4, 33, 31, 39],
       [ 1,  5,  6,  1, 32, 30, 30],
       [ 0,  6,  6,  6, 39, 37, 34]])
"""

tips:vstack和hstack函数只适用于二维数组，如果要堆叠一维数组，需要先使用reshape函数将其转换为二维数组，然后再进行堆叠操作。

切分

切分操作是指将一个数组或矩阵分割成多个较小的子数组或子矩阵的过程，在Numpy中可以用三个routines函数进行切分操作，即：split，vsplit，hsplit。

split

首先是split，split函数是将一个数组沿着指定的轴（维度）进行切分，axis方向上1为列，0为行，进行切割操作以后返回切分后多个子数组。切分操作可以根据切分点的位置或者切分的段数进行。
具体参数如下：

array(ary,indices_or_sections,axis=0)

• ary:被切分的数组
• indices_or_sections：切分索引或段数
  • 如果是一个整数n，则将数组切分为n个等大小的子数组
  • 如果是一个索引列表或数组，表示切分点的位置。切分点即切分后每个子数组的结束位置（不包含切分点本身）。
• axis：切分的轴（维度）。默认为0，表示沿着行的方向进行切分。

arr1 = np.random.randint(0,100,size=(6,5))
display(arr1)

"""
array([[57,  7, 51, 55, 95],
       [82,  3, 80, 14, 40],
       [ 8, 29,  4, 69, 79],
       [62, 21, 92, 21, 69],
       [53, 71, 87, 26, 87],
       [34, 32,  7, 35, 40]])
"""

a1 ,a2 = np.split(arr1,indices_or_sections=2,axis=0)
display(a1,a2)
"""
array([[57,  7, 51, 55, 95],
       [82,  3, 80, 14, 40],
       [ 8, 29,  4, 69, 79]])
array([[62, 21, 92, 21, 69],
       [53, 71, 87, 26, 87],
       [34, 32,  7, 35, 40]])
"""

indices_or_sections int 会按照指定的轴向，讲数组切分成N等分，要求切分的方向上的长度能被N整除，否则会导致报错：

np.split(arr, indices_or_sections=4, axis=0)

"""
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\Anaconda3\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
    777     try:
--> 778         len(indices_or_sections)
    779     except TypeError:

TypeError: object of type 'int' has no len()

During handling of the above exception, another exception occurred:

ValueError                                Traceback (most recent call last)
<ipython-input-247-bd9f74a4e1c4> in <module>()
----> 1 np.split(arr, indices_or_sections=4, axis=0)

~\Anaconda3\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
    782         if N % sections:
    783             raise ValueError(
--> 784                 'array split does not result in an equal division')
    785     res = array_split(ary, indices_or_sections, axis)
    786     return res

ValueError: array split does not result in an equal division

"""

indices_or_sections除了能直接进行整数的方式进行指定的切分，还能够使用[m,n]的表达式进行切分，[m,n]表达的是按照[0:m，m:n，n:] 的切片逻辑对数组进行拆分（左闭右开）
例如，我们按照[2:3]的表达式并沿着列方向进行切分arr1数组

dsplay(np.split(arr1,indices_or_sections=[2,3],axis=1))
"""
[array([[57,  7],
        [82,  3],
        [ 8, 29],
        [62, 21],
        [53, 71],
        [34, 32]]), array([[51],
        [80],
        [ 4],
        [92],
        [87],
        [ 7]]), array([[55, 95],
        [14, 40],
        [69, 79],
        [21, 69],
        [26, 87],
        [35, 40]])]
"""

这组表达式表示的是会将数组沿着列（axis=1）方向进行切分，生成三个子数组，原始数组将被分成三个部分：前两列、第三列和剩余的列。按照上面[m:n]的表达式其中0:2为第0，1列的数组，2:3表示第2列的数组，3:表示的是剩余的所有数组:

"""
0:2切分的数组
[array([[57,  7],
        [82,  3],
        [ 8, 29],
        [62, 21],
        [53, 71],
        [34, 32]])
"""

"""
2:3切分的数组
array([[51],
        [80],
        [ 4],
        [92],
        [87],
        [ 7]])
"""

"""
3:切分的剩余数组
array([[55, 95],
        [14, 40],
        [69, 79],
        [21, 69],
        [26, 87],
        [35, 40]])
"""

vsplit和hsplit

vsplit和hsplit是NumPy中用于沿着垂直方向和水平方向进行数组切分的函数。它们可以用来将数组沿着指定的轴（维度）进行切分，生成多个子数组。

• vsplit用于沿着垂直方向（行方向，axis=0）进行切分，将数组切分为多个垂直方向的子数组。

np.vsplit(array, indices_or_sections)

例如使用vsplit进行切分arr1，且indices_or_sections=2：

display(np.vsplit(arr1, indices_or_sections=2))

"""
[array([[57,  7, 51, 55, 95],
        [82,  3, 80, 14, 40],
        [ 8, 29,  4, 69, 79]]), 
 array([[62, 21, 92, 21, 69],
        [53, 71, 87, 26, 87],
        [34, 32,  7, 35, 40]])]
"""

从上面我们可以看到vsplit把数组分成两个，其中第一个数组为切分后的前3列数组，第二个数组为第切分后的剩余数组
当然我们也可以使用和上面split切分数组的[m,n]方法一样进行切分

display(np.vsplit(arr1,indices_or_sections=[2:3]))
"""
[array([[57,  7, 51, 55, 95],
        [82,  3, 80, 14, 40]]),
 array([[ 8, 29,  4, 69, 79]]),
 array([[62, 21, 92, 21, 69],
        [53, 71, 87, 26, 87],
        [34, 32,  7, 35, 40]])]
"""

• hsplit用于沿着水平方向（列方向，axis=1）进行切分，将数组切分为多个水平方向的子数组。

np.hsplit(array, indices_or_sections)

这两个函数的indices_or_sections参数与split函数类似，可以是整数或者索引列表，表示切分点的位置或切分的段数。
方法和vsplit类似：

display(np.hsplit(arr1, indices_or_sections=[2,3]))
"""
[array([[57,  7],
        [82,  3],
        [ 8, 29],
        [62, 21],
        [53, 71],
        [34, 32]]), array([[51],
        [80],
        [ 4],
        [92],
        [87],
        [ 7]]), array([[55, 95],
        [14, 40],
        [69, 79],
        [21, 69],
        [26, 87],
        [35, 40]])]
"""

以上就是数组切分的一些基本操作，为了能更好的理解上面的操作，不妨来做几道题来练练手吧：

1. 生成两个形状分别为（4，4）和（8，4）的二维整型数组，尝试级联

2. 使用两种方法将上题级联的结果保存并拆分成3等份

3. 生成一个长度为5的一维整型数组，将类型修改为float32

记得自己做过后再看答案哦！

答案：
第一题：

a1 = np.random.randint(0,10,size=(4,4))
a2 = np.random.randint(0,10,size=(8,4))

display(a1,a2)
"""
array([[3, 7, 1, 2],
       [2, 0, 2, 4],
       [0, 3, 1, 0],
       [0, 1, 3, 5]])
array([[2, 3, 5, 0],
       [2, 1, 0, 4],
       [7, 4, 5, 8],
       [5, 6, 4, 8],
       [3, 0, 8, 4],
       [6, 5, 4, 5],
       [6, 2, 9, 6],
       [6, 7, 7, 3]])
"""
display(np.concatenate((a1,a2),axis=0))
"""
array([[3, 7, 1, 2],
       [2, 0, 2, 4],
       [0, 3, 1, 0],
       [0, 1, 3, 5],
       [2, 3, 5, 0],
       [2, 1, 0, 4],
       [7, 4, 5, 8],
       [5, 6, 4, 8],
       [3, 0, 8, 4],
       [6, 5, 4, 5],
       [6, 2, 9, 6],
       [6, 7, 7, 3]])
"""

第二题：

# 第一种方法
display(np.split(arr,indices_or_sections=3))
"""
[array([[3, 7, 1, 2],
        [2, 0, 2, 4],
        [0, 3, 1, 0],
        [0, 1, 3, 5]]), 
 array([[2, 3, 5, 0],
        [2, 1, 0, 4],
        [7, 4, 5, 8],
        [5, 6, 4, 8]]), 
 array([[3, 0, 8, 4],
        [6, 5, 4, 5],
        [6, 2, 9, 6],
        [6, 7, 7, 3]])]
"""

# 第二种方法
display(np.split(arr, indices_or_sections=[4,8]))
"""
[array([[3, 7, 1, 2],
        [2, 0, 2, 4],
        [0, 3, 1, 0],
        [0, 1, 3, 5]]), 
 array([[2, 3, 5, 0],
        [2, 1, 0, 4],
        [7, 4, 5, 8],
        [5, 6, 4, 8]]), 
 array([[3, 0, 8, 4],
        [6, 5, 4, 5],
        [6, 2, 9, 6],
        [6, 7, 7, 3]])]
"""

第三题

data = np.random.randint(0, 10, size=5)
display(data.astype(np.float32))
"""
array([8., 1., 1., 4., 4.], dtype=float32)
"""

结语

以上就是本篇文章的所有内容，基于ndarry的读写可以让我们更灵活的操作Numpy，希望通过阅读上面的内容可以让你有所收获，如果有什么问题和想法欢迎评论留言和私信，大家一起交流学习，一起和🦈在数据科学的海洋中共同遨游吧。好了，纸上得来终觉浅，觉知此事要躬行，如果学到了东西不妨打开电脑练起来吧！