Numpy使用简略教程

讨论 小哲
Lv1 居士
发布在 NumPy   1427   0
讨论 小哲   1427   0

    0. NumPy的安装

    访问 https://www.anaconda.com/distribution/ ,根据电脑的系统下载对应的软件,安装完成在软件中选择JupyterLab即可使用。

    • 使用pip命令(保证您的Python环境已经配置完成)

    在CMD中输入python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose等待安装完成即可。

    附:安装验证

    输入下列代码能得到结果即代表着安装成功:

    from numpy import *
    eye(4)

    输出:

    array([[1., 0., 0., 0.],
           [0., 1., 0., 0.],
           [0., 0., 1., 0.],
           [0., 0., 0., 1.]])

    1. NumPy库简介

    NumPy是一个科学计算基础库其中提供了许多向量和矩阵操作,能让用户轻松完成最优化、线性代数、积分、插值、特殊函数、傅里叶变换、信号处理和图像处理、常微分方程求解以及其他科学与工程中常用的计算,不仅方便易用而且效率更高。

    2. NumPy

    NumPy数组的维数称为秩(rank),秩就是轴的数量,一位数组的秩为1,二维数组的秩为2,依次类推。在 NumPy中,每一个线性的数组称为是一个轴(axis),也就是维度(dimensions)。比如说,二维数组相当于是两个一维数组,其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴(axis),第一个轴相当于是底层数组,第二个轴是底层数组里的数组。而轴的数量——秩,就是数组的维数。很多时候可以声明 axis。axis=0,表示沿着第 0 轴进行操作,即对每一列进行操作;axis=1,表示沿着第1轴进行操作,即对每一行进行操作。

    2.1 Ndarray

    Ndarray(N维数组)对象是NumPy最重要的一个特点,它是一系列同类型数据的集合,以0下标为开始进行集合中元素的索引。ndarray对象是用于存放同类型元素的多维数组,其中的每个元素在内存中都有相同存储大小的区域,该对象具有矢量算术能力和复杂的广播能力。可以执行一些科学运算,ndarray对象中定义了一些重要属性,如下表所示:

    属性 说明
    ndarray.ndim 秩,即轴的数量或维度的数量
    ndarray.shape 数组的维度,对于矩阵,n 行 m 列
    ndarray.size 数组元素的总个数,相当于 .shape 中 n*m 的值
    ndarray.dtype ndarray 对象的元素类型
    ndarray.itemsize ndarray 对象中每个元素的大小,以字节为单位
    ndarray.flags ndarray 对象的内存信息
    ndarray.real ndarray元素的实部
    ndarray.imag ndarray 元素的虚部
    ndarray.data 包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。

    示例:

    import numpy as np
    data = np.arange(12).reshape(3, 4)
    print("data=", data)
    print("type(data)=", type(data))
    print("data.ndim=", data.ndim)
    print("data.shape=", data.shape)
    print("data.size=", data.size)
    print("data.dtype=", data.dtype)

    输出:

    data= [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    type(data)= <class 'numpy.ndarray'>
    data.ndim= 2
    data.shape= (3, 4
    data.size= 12
    data.dtype= int32

    解析:

    在代码示例中,第一行将numpy库导入并将其取名为np,第二行初始化一个三行四列的递增数组data,第三行输出data,第四行输出data的类型,第五行输出了数组的维度个数,第六行输出了数组的维度,第七行输出了数组中元素的总个数,第八行输出了元素的类型。

    2.1.1 常用属性
    • ndarray.shape属性

    ndarray.shape 表示数组的维度,返回一个元组,这个元组的长度就是维度的数目,即 ndim 属性(秩)。比如,一个二维数组,其维度表示"行数"和"列数"。ndarray.shape 也可以用于调整数组大小。

    代码:

    import numpy as np
    data = np.arange(12)
    print("更改前的数组:", data)
    data.shape = (3, 4)
    print("更改后的数组:", data)

    输出:

    更改前的数组: [ 0  1  2  3  4  5  6  7  8 
     9 10 11]
    更改后的数组: [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    • reshape()函数

    reshape()函数可用来调整数组大小,例如:

    import numpy as np
    data = np.arange(12)
    print("更改前的数组:", data)
    data.shape = (3, 4)
    print("更改后的数组:", data)
    print("reshape后数值:", data.reshape(2,6))

    输出:

    更改前的数组: [ 0  1  2  3  4  5  6  7  8 
     9 10 11]
    更改后的数组: [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    reshape后数值: [[ 0  1  2  3  4  5]       
     [ 6  7  8  9 10 11]]
    • ndarray.flags属性

    ndarray.flags 返回 ndarray 对象的内存信息,包含以下属性:

    属性 描述
    C_CONTIGUOUS (C) 数据是在一个单一的C风格的连续段中
    F_CONTIGUOUS (F) 数据是在一个单一的Fortran风格的连续段中
    OWNDATA (O) 数组拥有它所使用的内存或从另一个对象中借用它
    WRITEABLE (W) 数据区域可以被写入,将该值设置为 False,则数据为只读
    ALIGNED (A) 数据和所有元素都适当地对齐到硬件上
    UPDATEIFCOPY (U) 这个数组是其它数组的一个副本,当这个数组被释放时,原数组的内容将被更新

    代码:

    import numpy as np 
    
    x = np.array([1,2,3,4,5])  
    print (x.flags)

    输出:

      C_CONTIGUOUS : True
      F_CONTIGUOUS : True
      OWNDATA : True
      WRITEABLE : True
      ALIGNED : True
      WRITEBACKIFCOPY : False
      UPDATEIFCOPY : False

    2.2 创建NumPy数组

    2.2.1 使用array()函数创建数组

    语法:

    array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0, /)
    名称 描述
    object 数组或嵌套的数列
    dtype 数组元素的数据类型,可选
    copy 对象是否需要复制,可选
    order 创建数组的样式,C为行方向,F为列方向,A为任意方向(默认),可选
    subok 默认返回一个与基类类型一致的数组,可选
    ndmin 指定生成数组的最小维度,可选

    示例:

    import numpy as np
    data = np.array([1, 2, 3])
    data2 = np.array((1, 2, 3))
    data3 = np.array(((1, 2, 3), (4, 5, 6)))
    data4 = np.array([1, 2, 3, 4, 5], complex, ndmin=2)
    print("data=", data)
    print("data2=", data2)
    print("data3=", data3)
    print("data4=", data4)

    输出:

    data= [1 2 3]
    data2= [1 2 3]
    data3= [[1 2 3]
     [4 5 6]]
    data4= [[1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]]

    解析:

    可以通过array()函数由列表元组转化,由列表/元组转化为多维数组需要子元素为列表/元组的列表/元组,即:

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

    都是可以的。

    2.2.2 numpy创建数组
    • empty()函数

    创建一个只分配内存空间的数组,其中的元素将随机填充。

    语法:

    empty(shape, dtype=float, order='C', /)
    名称 描述
    shape 数组的维度,例如(2,3)代表两行三列
    dtype 数组元素的类型,可选,默认为float64
    order 创建数组的样式,C为行方向,F为列方向,A为任意方向(默认),可选

    代码:

    import numpy as np
    data = np.empty((3, 5))
    print(data)

    输出:

    [[6.23042070e-307 4.67296746e-307 1.69121096e-306 2.31424250e-306
      1.89146896e-307]
     [7.56571288e-307 3.11525958e-307 1.24610723e-306 1.37962320e-306       
      1.29060871e-306]
     [2.22518251e-306 1.33511969e-306 1.78022342e-306 1.05700345e-307       
      2.76676762e-322]]
    • zeros()ones()函数

    zeros()将创建一个用指定形状用0填充的数组。默认的dtype是float64。

    ones()将创建一个用指定形状用1填充的数组。默认的dtype是float64。

    语法:

    zeros(shape, dtype=float, order='C', /)
    ones(shape, dtype=None, order='C')
    名称 描述
    shape 数组的维度,例如(2,3)代表两行三列
    dtype 数组元素的类型,可选
    order 创建数组的样式,C为行方向,F为列方向,A为任意方向(默认),可选

    代码:

    import numpy as np
    data_0 = np.zeros((2, 3))
    data_1 = np.ones((3, 2))
    print("data_0=", data_0)
    print("data_1=", data_1)

    输出:

    data_0= [[0. 0. 0.]
     [0. 0. 0.]]
    data_1= [[1. 1.]
     [1. 1.]
     [1. 1.]]
    2.2.3 从数值范围创建数组
    • arange()函数

    arrange()函数将创建具有有规律递增值的数组。

    语法:

    arange(start=None, stop, step=None,dtype=None, /)
    名称 描述
    Start 开始数值,可选,所输出的数组中包括开始数值
    stop 结束数值,若不定义则默认从0开始,单独使用时仅可使用正数,所输出的数组中不包括结束数值
    step 步长,可正可负可为小数,可选
    dtype 数组中的元素类型

    代码:

    import numpy as np
    data = np.arange(10)
    data1 = np.arange(1, 10)
    data2 = np.arange(1, 10, 2)
    data3 = np.arange(10, 1, -2)
    dataf = np.arange(1, 10, 2, float)
    print("data=", data)
    print("data1=", data1)
    print("data2=", data2)
    print("data3=", data2)
    print("dataf=", dataf)

    输出:

    data= [0 1 2 3 4 5 6 7 8 9]
    data1= [1 2 3 4 5 6 7 8 9]
    data2= [1 3 5 7 9]
    data3= [1 3 5 7 9]
    dataf= [1. 3. 5. 7. 9.]
    • linspace()函数

    linspace() 将创建具有指定数量元素的数组,并在指定的开始值和结束值之间平均间隔。该数组为指定起始值的等差数列。

    语法:

    linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
    名称 描述
    start 序列的起始值
    stop 序列的终止值
    num 序列的项数,默认为50项
    endpoint 是否包括stop默认包括
    retstep 是否输出步长,默认不输出
    dtype 元素属性,默认为float64
    axis 操作维度,可选值0/-1,可选

    代码:

    import numpy as np
    data = np.linspace(0,6,3,endpoint=False)
    data_2 = np.linspace(0,6,3)
    print(data)
    print(data_2)

    输出:

    [0. 2. 4.]
    [0. 3. 6.]
    • logspace()函数

    logspace()用于创建一个等比数列。

    语法:

    np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
    参数 描述
    start 序列的起始值
    stop 序列的终止值
    num 要生成的等步长的样本数量,默认为50
    endpoint 该值为 true 时,数列中中包含stop值,反之不包含,默认是True。
    base 对数 log 的底数,默认底数为10。
    dtype ndarray 的数据类型,默认为float64

    $$ 数组为:[{base}^{start},……,{base}^{stop}],其中endpoint=True $$

    代码:

    import numpy as np
    a = np.logspace(0, 9, 10, base=2)
    print(a)

    输出:

    [  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]
    2.2.4 从已有的数组创建数组
    • asarray()函数

    语法:

    numpy.asarray(a, dtype = None, order = None)
    参数 描述
    a 任意形式的输入参数,可以是,列表, 列表的元组, 元组, 元组的元组, 元组的列表,多维数组
    dtype 数据类型,可选
    order 可选,有"C"和"F"两个选项,分别代表,行优先和列优先,在计算机内存中的存储元素的顺序。

    代码:

    import numpy as np
    x = [1, 2, 3]
    y = (4, 5, 6)
    z = [(7, 8), (9, 10, 11)]
    # 从列表创建数组
    a = np.asarray(x)
    # 从元组创建数组
    b = np.asarray(y)
    # 从元组列表创建数组
    c = np.asarray(z)
    print(a, b, c)

    输出:

    [1 2 3] [4 5 6] [(7, 8) (9, 10, 11)]

    当然,asarray也可以设置dtype属性,例如:

    import numpy as np 
    
    x =  [1,2,3] 
    a = np.asarray(x, dtype =  float)  
    print (a)

    输出为:

    [ 1.  2.  3.]
    • frombuffer()函数

    numpy.frombuffer 用于实现动态数组。numpy.frombuffer 接受 buffer 输入参数,以流的形式读入转化成 ndarray 对象。

    语法:

    numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

    注意:buffer 是字符串的时候,Python3 默认 str 是 Unicode 类型,所以要转成 bytestring 在原 str 前加上 b。

    参数 描述
    buffer 可以是任意对象,会以流的形式读入。
    dtype 返回数组的数据类型,可选
    count 读取的数据数量,默认为-1,读取所有数据。
    offset 读取的起始位置,默认为0。

    代码:

    import numpy as np 
    
    s =  b'Hello World' 
    a = np.frombuffer(s, dtype =  'S1')  
    print (a)

    输出:

    [b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']

    2.3 数据类型

    numpy 支持的数据类型比 Python 内置的类型要多很多,基本上可以和 C 语言的数据类型对应上,其中部分类型对应为 Python 内置的类型。下表列举了常用 NumPy 基本类型,参考链接: 菜鸟编程 NumPy 中文网

    名称 描述
    bool_ 布尔型数据类型(True 或者 False)
    int_ 默认的整数类型(类似于 C 语言中的 long,int32 或 int64)
    intc 与 C 的 int 类型一样,一般是 int32 或 int 64
    intp 用于索引的整数类型(类似于 C 的 ssize_t,一般情况下仍然是 int32 或 int64)
    int8 字节(-128 to 127)
    int16 整数(-32768 to 32767)
    int32 整数(-2147483648 to 2147483647)
    int64 整数(-9223372036854775808 to 9223372036854775807)
    uint8 无符号整数(0 to 255)
    uint16 无符号整数(0 to 65535)
    uint32 无符号整数(0 to 4294967295)
    uint64 无符号整数(0 to 18446744073709551615)
    float_ float64 类型的简写
    float16 半精度浮点数,包括:1 个符号位,5 个指数位,10 个尾数位
    float32 单精度浮点数,包括:1 个符号位,8 个指数位,23 个尾数位
    float64 双精度浮点数,包括:1 个符号位,11 个指数位,52 个尾数位
    complex_ complex128 类型的简写,即 128 位复数
    complex64 复数,表示双 32 位浮点数(实数部分和虚数部分)
    complex128 复数,表示双 64 位浮点数(实数部分和虚数部分)
    2.3.1 查看数据类型

    通过ndarray.dtype可以创建一个表示数据类型的对象,如果想要获取数据类型名称,需要访问name属性进行获取,例如:

    import numpy as np
    data = np.array([[1, 2, 3], [4, 5, 6]])
    print(data.dtype.name)

    本段代码在64位Windows系统将输出int32,在64位Linux或MacOS中将输出int64

    2.3.2 创建数据类型

    可以通过如下语法构造dtype对象

    numpy.dtype(object, align, copy)
    • object - 要转换为的数据类型对象
    • align - 如果为 true,填充字段使其类似 C 的结构体。
    • copy - 复制 dtype 对象 ,如果为 false,则是对内置数据类型对象的引用

    每一个NumPy内置的数据类型都有一个特征码,它能唯一标识一种数据类型,具体如表所示:

    特征码 含义 特征码 含义
    b 布尔型 i 有符号整型
    u 无符号整型 f 浮点型
    c 复数类型 O Python对象
    S,a 字节字符串 U unicode字符串
    V 原始数据

    字节顺序是通过对数据类型预先设定"<"或">"来决定的。"<"意味着**小端法**(最小值存储在最小的地址,即低位组放在最前面)。">"意味着大端法(最重要的字节存储在最小的地址,即高位组放在最前面)。例如如下代码:

    import numpy as np
    # 创建car类型
    car = np.dtype([('name', 'a3'), ('age', 'i1'), ('speed', 'f4')])
    # 创建dtype为car类型的数组
    a = np.array([('xz', 1, 20), ('ln', 2, 10)], dtype=car)
    print(a)

    输出为:

    [(b'xz', 1, 20.) (b'ln', 2, 10.)]
    2.3.3 转换数据类型
    • astype()函数

    该函数可以对ndarray对象的数据类型进行转换。

    代码:

    import numpy as np
    data = np.zeros((2, 3))
    print("修改前的类型:", data.dtype)
    int_data = data.astype(np.int64)
    print("修改后的类型", int_data.dtype)

    输出:

    修改前的类型: float64
    修改后的类型 int64

    2.4 切片和索引

    2.4.1 一维切片

    在Python中接触过使用list函数的切片操作,ndarray对象内容可以同样通过索引或切片操作来访问和修改,基于0 - n的下标进行索引,使用内置的slice函数,设置startstopstep参数,从原数组中切割出一个新数组,其中slice语法为:

    slice(start: Any, stop: Any, step: Any=...)
    slice(stop)
    slice(start, stop[, step])
    参数 说明
    start 索引开始
    stop 索引结束
    step 索引步长

    代码:

    import numpy as np
    a = np.arange(10)
    s = slice(2, 7, 2)   # 从索引 2 开始到索引 7 停止,间隔为 2
    print(a[s])

    输出:

    [2 4 6]

    当然也可以直接通过冒号分割切片参数start:stop:step来进行切片操作:

    代码:

    import numpy as np
    a = np.arange(10)
    b = a[2:7:2]    # 从索引 2 开始到索引 7 停止,间隔为 2
    print(b)

    输出:

    [2 4 6]
    有关:的解释
    • 放置一个参数返回与该索引相对应的单个元素[2],也可使用负数进行负索引
    import numpy as np
    a = np.arange(10)
    print(a[2], " ", a[-2])

    输出为:2 8

    • 如果使用[2:]则输出从该索引(包括该元素)之后的所有项
    import numpy as np
    a = np.arange(10)
    print(a[2:])

    输出为:[2 3 4 5 6 7 8 9]

    • 如果使用[:7]则输出从该索引(不包括该元素)之前的所有项
    import numpy as np
    a = np.arange(10)
    print(a[:7])

    输出为:[0 1 2 3 4 5 6]

    • 如果使用[2:7]那么则提取两个索引(不包括停止索引)之间的项
    import numpy as np
    a = np.arange(10)
    print(a[2:7])

    输出为:[2 3 4 5 6]

    • 同样可以使用负值对数组进行反转[::-1]
    import numpy as np
    a = np.arange(10)
    print(a[::-1])

    输出为:[9 8 7 6 5 4 3 2 1 0]

    • 多维数组同样适用上述索引提取方法
    import numpy as np
    a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
    print(a)
    # 从某个索引处开始切割
    print('从数组索引 a[1:] 处开始切割')
    print(a[1:])

    输出为:

    [[1 2 3]
     [3 4 5]
     [4 5 6]]
    从数组索引 a[1:] 处开始切割
    [[3 4 5]
     [4 5 6]]

    更多例子:

    import numpy as np
    a = np.arange(10)
    print(a[1:9:2])  # 输出在索引为1和9之间(不包括9)步长为2的元素
    print(a[9:1:-2])  # 反向输出在索引为9和1之间(不包括1)步长为2的元素

    输出为:

    [1 3 5 7]
    [9 7 5 3]
    2.4.2 多维切片

    冒号分割函数在多维数组的处理上也很方便,在多维数组切片[x,y],x代表行号,y代表列号,例如下图中为二维数组中对应的冒号索引。

    undefined

    例如下列代码:

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

    输出为10,即为第2行第1列的元素。在多维数组的每一维同样可以使用:索引,在讲解多维数组下的:索引之前先引入一下省略号切片:

    undefined

    如图所示,如果需要输出第2行元素只需使用:

    import numpy as np
    a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
    print(a[2, ...])
    print(a[2])    # 当省略号代表列时可省略

    而输出第2列元素可以使用:

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

    多维数组下的:索引

    创建一个4×4的二维数组,一些区域访问的例子如下图所示:

    undefined

    代码:

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

    输出:

    [5 9]
    [10 14]
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]]
    [[ 1  2  3]
     [ 5  6  7]
     [ 9 10 11]
     [13 14 15]]
    [ 3 11]
    [15  7]
    [[2 3]
     [6 7]]
    [[ 1  2  3  4]
     [ 9 10 11 12]]
    [[13 14 15 16]
     [ 5  6  7  8]]

    如果我们需要填充一个8×8的棋盘,黑的为0,白的为1,可以使用:索引迅速填充:

    import numpy as np
    chess = np.zeros((8, 8), int)
    chess[::2, 1::2] = 1
    chess[1::2, ::2] = 1
    print(chess)
    2.4.3 花式索引与布尔索引

    花式索引的基本形式如下图所示:

    undefined

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

    输出为:

    [[ 1  2  3  4]
     [13 14 15 16]]
    [[ 1  4]
     [ 5  8]
     [ 9 12]
     [13 16]]
    [ 2 16]
    [ 1  7 12  2 15]

    当花式索引使用一个数组做索引,即a[[x,y]]a[..., [x,y]]形式时,输出第x,y行/列的元素,而当使用两个数组做索引,即a[[x,y],[m,n]]形式时,输出第xm列和第y行第n列的元素。

    np.ix_

    undefined

    代码:

    import numpy as np
    
    x = np.arange(32).reshape((8, 4))
    print(x[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])])
    print(x[[1, 5, 7, 2], [0, 3, 1, 2]])

    输出:

    [[ 4  7  5  6]
     [20 23 21 22]
     [28 31 29 30]
     [ 8 11  9 10]]
    [ 4 23 29 10]

    可以看出np.ix_方法第一个参数指定的是行,第二个参数指定的该行选取列的顺序。

    布尔索引指的是将一个布尔数组作为数组索引,返回的数据是布尔数组中True对应位置的值,比如一个简单的例子:

    考试结束五个同学的成绩如下表:

    zz 98 64 87
    yxy 100 92 76
    wyf 67 99 90
    wcc 80 100 99
    zyh 79 95 66

    使用student存储姓名,使用student_score存储学生成绩,使用布尔索引输出姓名为zyh的成绩

    代码:

    import numpy as np
    student = np.array(['zz', 'yxy', 'wyf', 'wcc', 'zyh'])
    student_score = np.array([[98, 64, 87], [100, 92, 76], [67, 99, 90],
                              [80, 100, 99], [79, 95, 66]])
    
    print(student == 'zyh')
    # 将布尔数组作为索引应用于存储成绩的数组,返回的数据是True值对应的行
    print(student_score[student == 'zyh'])
    # 布尔型数组与切片混合使用
    print(student_score[student == 'zyh', 1:])

    输出:

    [False False False False  True]
    [[79 95 66]]
    [[95 66]]

    在使用布尔型索引获取值得时候,除了可以使用"=="运算符还可以使用"!="、"-"来进行否定、">"和"<"来判断数值大小以及"&"和"|"等符号来组合多个布尔条件。

    版权声明:作者保留权利,不代表意本站立场。如需转载请联系本站以及作者。

    参与讨论

    回复《 Numpy使用简略教程

    EditorJs 编辑器

    沙发,很寂寞~
    反馈
    to-top--btn