精华内容
下载资源
问答
  • 注:最近在看代码,有好多关于numpy库的函数,尤其对于numpy数组,什么[:,2]、[-1:,0:2]...numpy数组切片操作 通过冒号分隔切片参数 start:stop:step 来进行切片操作: 形如: b = a[2:7:2] # 从索引 2 开始到索引 7...

    注:最近在看代码,有好多关于numpy库的函数,尤其对于numpy数组,什么[:,2]、[-1:,0:2]、[1:,-1:]搞得一脸懵逼,百度没找到解释得很到位的,官网教程也也真是够简洁的。所以,还是得自己去实打实的敲一下,加强理解。

    numpy数组切片操作

    通过冒号分隔切片参数 start:stop:step 来进行切片操作:
    形如:

    b = a[2:7:2]   # 从索引 2 开始到索引 7 停止,间隔为 2
    

    冒号 : 的解释:如果只放置一个参数,如 [2],将返回与该索引相对应的单个元素。如果为 [2:],表示从该索引开始以后的所有项都将被提取。如果使用了两个参数,如 [2:7],那么则提取两个索引(不包括停止索引)之间的项。

    一维数组

    一维数组就如上所说,直接给例子看

    >>>import numpy as np
    >>>a = np.array([1,2,3,4,5,6,7,8])
    

    1.只有一个参数

    >>> a[1] #具体的元素 2
    2
    >>> a[1:] #冒号前面是起,后面是止,冒号前面空,指最小0,后面放空就是到最后,这里是一维数组
    array([2, 3, 4, 5, 6, 7, 8])
    

    对比一下下面这两个,一个是一维数组,一个是具体的单个元素,为什么呢?看后面解释。

    >>> a[7:]
    array([8])
    >>> a[7]
    8
    

    2.两个参数

    >>> print(a[1:3])  #从索引1开始,也就是第二个元素2,到索引3,不包括索引3
    [2 3]
    

    3.三个参数

    >>> print(a[1:7:2]) #从索引1开始,到索引7,不包括索引7,间隔为2
    [2 4 6]
    

    一维数组,很好理解,毕竟中括号[]里只有冒号,没有逗号

    二维数组

    先定义一个二维数组

    >>> import numpy as np
    >>> a = np.array([[1,2,3],[3,4,5],[4,5,6]])
    >>>print(a)
    [[1 2 3]
     [3 4 5]
     [4 5 6]]
    
    简单:
    >>> a[1]
    array([3, 4, 5])
    

    单个参数的话,就是指的是1,第二行或第二列。这里是行,因为行优先我猜。
    所以就是第2行的元素

    >>> a[1:]
    array([[3, 4, 5],
          [4, 5, 6]])
    

    出现了冒号,意思是从第二号到最后,这里指的也是行。冒号后面没有数就是指最大的。冒号前面没有数,就是指最小数0。如下

    >>> a[:2]
    array([[1, 2, 3],
          [3, 4, 5]])
    

    这里的意思就是,从0开始,到2,也就是第1行第二行。(第三行不算)

    >>> a[1:2]
    array([[3, 4, 5]])
    

    现在是两个参数了,不过只有一个冒号,跟一维数组一样,是从第二行到第三行,不包括第三行。

    进阶
    >>> a[1,]
    array([3, 4, 5])
    >>> a[1:,]
    array([[3, 4, 5],
          [4, 5, 6]])
    >>> a[:2,]
    array([[1, 2, 3],
          [3, 4, 5]])
    >>> a[1:2,]
    array([[3, 4, 5]])
    

    跟上面三个对比一下,发现输出一模一样。

    总结:

    这是numpy的切片操作,一般结构如num[a:b,c:d],分析时以逗号为分隔符
    逗号之前为要取的num行的下标范围(a到b-1),逗号之后为要取的num列的下标范围(c到d-1);
    前面是行索引,后面是列索引
    如果是这种num[:b,c:d],a的值未指定,那么a为最小值0;
    如果是这种num[a:,c:d],b的值未指定,那么b为最大值;c、d的情况同理可得。

    所以重点就是看逗号,没逗号,就是看行了,冒号呢,就看成一维数组的形式啦。那上面逗号后面没有树,也就是不对列操作咯。
    当然也可以这样:

    >>> a[:2:1]
    array([[1, 2, 3],
        [3, 4, 5]])
    

    首先没有逗号,那切片就是只看行了,这里的意思是,从0开始到2(2不算),间隔为1。

    进阶up

    首先先把原数组再看一下。

    >>> import numpy as np
    >>> a = np.array([[1,2,3],[3,4,5],[4,5,6]])
    >>>print(a)
    [[1 2 3]
    [3 4 5]
    [4 5 6]]
    
    >>> a[:,1]
    array([2, 4, 5])
    

    逗号前面是行,行都没有指定数,也就是说对行每要求,只考虑列了。
    这里的意思是:逗号之后是列,只有一个元素1,就是取第2列了。

    >>> a[:,1:3]  #第2列到第3列
    array([[2, 3],
          [4, 5],
          [5, 6]])
    >>> a[:,0:2] #第1列到第2列
    array([[1, 2],
          [3, 4],
          [4, 5]])
    >>> a[:,]  #对列也不操作,跟下面等价
    array([[1, 2, 3],
          [3, 4, 5],
          [4, 5, 6]])
    >>> a[:,:]
    array([[1, 2, 3],
          [3, 4, 5],
          [4, 5, 6]])
    

    但是,下面的写法是错的!!!就是逗号在最前面都是错的

    >>> a[,1]
     File "<stdin>", line 1
       a[,1]
         ^
    SyntaxError: invalid syntax
    >>> a[,]
     File "<stdin>", line 1
       a[,]
         ^
    SyntaxError: invalid syntax
    >>> a[,:1]
     File "<stdin>", line 1
       a[,1]
         ^
    SyntaxError: invalid syntax
    

    到这,应该能基本看得懂所有的切片操作了吧!!!
    但是,我们可能还会遇到负号,比如-1、-2…等这些。这些怎么理解呢
    看下图
    在这里插入图片描述
    也就是说,-1就是指最后一个(行/列),依次递推。

    实战一波
    >>> a[:,-1]  #就是最后一列啦
    array([3, 5, 6])
    >>> a[:,-3:]  #倒3列,也就是这个数组的第一列,一直到最后。
    array([[1, 2, 3],
          [3, 4, 5],
          [4, 5, 6]])
    >>> a[:,-3:-1]  #倒3列,到倒1列,不包括倒一列。
    array([[1, 2],
          [3, 4],
          [4, 5]])
    

    其他行和列就都差不多啦

    ok,现在看看稍微难理解的。

    进阶upup

    对比一下下面两个,发现他们的维度不同,一个是一维的,一个是二维的。
    我们上面也遇到一个,一个是一维,一个是具体的单个元素。

    >>> a[:,-1]
    array([3, 5, 6])
    
    >>> a[:,-1:]
    array([[3],
          [5],
          [6]])
    

    我的理解:

    第一个是,指定了最后一列,也就是说,在二维数组里的一列,就是一维的啊。那么第二个,是从最后一列开始,不妨假设一下后面还有列,那么就应该是不止一列,对机器来说,就是二维的。机器肯定不知道什么时候是一维,什么时候是二维的,所以当你用到start和stop的时候,那就当作是二维的了。

    我的建议:

    官网给出的教程实在是太简洁了。不够详细,所以啊,还是要自己动动手,就能很快明白numpy数组的切片操作了。

    注;以上就是博主能想到的所以切片操作了吧,关于我的理解,如果有误的话,还请大佬指出,共同学习呀。


    更新2021.10.13

    有大半年没有更新博客了,这段时间一直准备春招,实习,秋招,到今天基本上可以结束坐等开奖了;
    目前手里有近10个CV算法工程师意向书:字节,商汤,百度,顺丰,华为,小红书,拼多多,小马智行,海康威视,腾讯等
    接下来会花很多时间在小红书上整理这一过程所有的经验以及技巧,包括:丰富简历内容,如何打比赛(大佬止步),如何刷题,刷什么题,刷到什么程度,面试技巧,面经整理,hr面技巧,如何反问面试官,如何argue薪资等等等,大家有需要可以关注一波哈,内容保证丰富!助力大家秋招收割offer到手软!

    大家如果是刚研一或者已经研二或者是大二或者大三赶紧关注一波,关注我秋招不踩坑!

    小红书号:371845174(Activewaste,博客同名)

    后面也会在小红书分享好用工具,插件,装逼神器等,手把手教学,大家关注起来哈!
    我看有粉丝评论私信求更新的,大受鼓舞哈哈哈哈,后面会继续更新论文笔记,供大家参考互相学习!!!
    另外我比较少上csdn,大家给我私信要联系方式或者评论问问题有时没看到(一个月没上,200+的通知),大家直接去小红书私信提问,或者催我撒!

    在这里插入图片描述

    展开全文
  • 一、numpy切片操作,一般结构如num[a:b,c:d],以逗号为分隔符,逗号之前为要取的num矩阵行的下标范围(a到b-1),逗号之后为要取的num矩阵列的下标范围(c到d-1);如果是这种num[:b,c:d],a的值未指定,默认a从0开始...

    一、numpy的切片操作,一般结构如num[a:b,c:d],以逗号为分隔符,逗号之前为要取的num矩阵行的下标范围(a到b-1),逗号之后为要取的num矩阵列的下标范围(c到d-1);如果是这种num[:b,c:d],a的值未指定,默认a从0开始计数;如果是这种num[a:,c:d],b的值未指定,默认从a到最后一行;c、d的情况同理可得。

    例1:

    import numpy as np
    num = np.arange(16).reshape((4,4 ))
    print(num)
    y=num[:3, :2]
    print(y)
    

    运行结果:

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

    二、num[a:b,None],表示该维不进行切片,而是将该维整体作为数组元素处理,最后形成一个三维数组
    例2;

    import numpy as np
    num = np.arange(16).reshape((4, 4))
    print(num)
    y=num[:3,None]
    print(y)
    

    运行结果:

    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]]
     
    [[[ 0  1  2  3]]
    
     [[ 4  5  6  7]]
    
     [[ 8  9 10 11]]]
    
    展开全文
  • 关于Numpy数组切片操作的整理与思考

    千次阅读 2018-07-29 17:34:43
    1.Python3中切片的定义 切片的语法表达式为:[start_index : end_...切片操作是指按照步长,截取从起始索引到结束索引,但不包含结束索引(也就是结束索引减1)的所有元素。 python3支持切片操作的数据类型有list...

    1.Python3中切片的定义

    切片的语法表达式为:[start_index : end_index : step],其中:

    • start_index表示起始索引
    • end_index表示结束索引
    • step表示步长,步长不能为0,且默认值为1

    切片操作是指按照步长,截取从起始索引到结束索引,但不包含结束索引(也就是结束索引减1)的所有元素。

    • python3支持切片操作的数据类型有list、tuple、string、unicode、range
    • 切片返回的结果类型与原对象类型一致
    • 切片不会改变原对象,而是重新生成了一个新的对象(注意此处与Numpy中的切片操作的不同之处,Numpy切片得到的是原多维数组的一个 视图(view) ,修改切片中的内容会导致原多维数组的内容也发生变化)

    2.一维数组的切片操作

    一维数组的切片操作与Python列表的切片操作很相似,几个特殊的情况说明如下(L是一个包含int64整型数字的一维数组):

    • 对于从前往后切片的情况:如果第一个索引是0,可以省略,即写出如下形式:L[:3](与L[0:3]等同)。同样的,与上述类似,对于从后往前切片的情况,最后一位的索引也是可以省略的(但是不是-1,-1只是最后一个元素的索引),因此以下两种情况是不相同的:
      • L[-2:]表示从倒数第二个数取到最后
      • L[-2:-1]表示取区间[-2, -1)范围内的数,也就是倒数第二个数

    补充:L[-1]与L[-1:]均可得到最后一个数,但是L[-1]表示索引取数,取出来的就是一个数字
    ,而L[-1:]取出来的是一个子数组(对应到numpy就是ndarray类型),子数组中仅包含最后一个数字。

    • 对于step的用法,有以下特殊情况:
      • L[::5]表示从第0个数开始,所有数,每5个取一个(这个切片操作把start_index和end_index均省略了)
      • L[::-1]表示翻转整个数组
      • L[:]表示复制整个数组

    3.多维数组的切片操作

    注意:对于多维数组的切片操作,将不同维度上的切片操作用逗号分开就好了


    以下是一些特殊情况的说明(由于多维数组中索引和切片常有联系,故以下情况会掺杂索引和切片的内容):

    (1).索引操作

    单个元素的索引操作

    以下两种情况等价,均为取第一维、第二维、第三维均为0的数字。对于第一种索引方法:每个维度一个索引值,用逗号分隔开,而第二种方法为常规方法。

    b = np.arange(24).reshape(2, 3, 4)
    print(b)
    print(b[0, 0, 0])
    print(b[0][0][0])
    
    output:
    '''
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
    
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]
    '''

    拓展:

    • 倘若写成如下形式:
      • b[:, 0, 0]为切片操作,考虑第一维,:表示全取,故第一维全取,而第二维为0,表示取下[0, 1, 2, 3]、[12, 13, 14, 15]这两个数组,第三维为0,表示在第二个维度中得到的结果,再取第0个索引的结果,也就得到[0, 12]
      • 同理,当写成b[0, :, :]时,表示取第一维为0的全部元素,另外还有一种写法是b[0]
      • 多个冒号可以用一个省略号(…)来代替,因此上面的代码等价于b[0, …]

    多个元素的索引操作

    对于单个元素的索引操作,似乎索引方法和常规方法无异,但是对于多个元素的索引操作,则体现其简洁性。

    1.用逗号分隔的数组序列

    • 序列的长度和多维数组的维数要一致
    • 序列中每个数组的长度要一致

    例如:

    arr = np.array([
        [1, 2, 3, 4],
        [2, 4, 6, 8],
        [3, 6, 9, 12],
        [4, 8, 12, 16]
    ])
    
    print(arr[[0, 2], [3, 1]])
    
    output:
    '''
    [4, 6]
    '''

    上述代码解释:
    首先第一个序列表示操作第一个维度,也就是选择第0行和第2行,之后再对第二个维度进行操作,也就是对第0行选择第3列,对第3行选择第2列。shape: (m, n, p)其中m,n,p分别表示第一、第二、第三个维度。

    2.boolean/mask index

    所谓 boolean index,就是用一个由 boolean 类型值组成的数组来选择元素的方法。具体参考以下代码即可:

    import numpy as np
    
    arr = np.array([[1, 2, 3, 4],
                    [2, 4, 6, 8],
                    [3, 6, 9, 12],
                    [4, 8, 12, 16]])
    mask = arr > 5
    
    print('boolean mask is:')
    print(mask)
    
    print(arr[mask])
    
    output:
    '''
    boolean mask is:
    [[False False False False]
     [False False  True  True]
     [False  True  True  True]
     [False  True  True  True]]
    [ 6  8  6  9 12  8 12 16]
    '''

    (2).切片操作

    具体例子如下:

    b = np.arange(24).reshape(2, 3, 4)
    print(b)
    
    output:
    '''
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
    
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]
    '''
    
    print(b[0, 1, ::2])
    
    output:
    '''
    [4 6]
    '''
    
    # 第一维为0,第二维不指定,第三维为最后一个索引
    print(b[0, :, -1])
    
    output:
    '''
    [3 7 11]
    '''
    
    print(b[0, ::-1, -1])
    
    output:
    '''
    [11 7 3]
    '''
    
    print(b[::-1])
    
    output:
    '''
    [[[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]
    
     [[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]]
    '''
    
    # 如果在多维数组中执行翻转一维数组的命令,将在最前面的维度上翻转元素的顺序
    print(b[::-1].shape)
    
    output:
    '''
    (2, 3, 4)
    '''

    4.总结

    对于Numpy切片操作的问题总结如下:

    • 如果是一维数组,那么在numpy上的切片操作与Python3 list的切片操作类似;
    • 如果是多维数组,那么不同维度上的切片操作用逗号分开,后续每一维的操作是在前一维操作的基础上再进行相关操作的(第一维的操作是在原数组上)。
    • 对于一些特殊情况,例如多个冒号可以省略不写,反向选取等也与第二点类似(也就是说一维一维下去进行的操作是一样的,只不过这里的操作比较特殊),对于一些维度上的操作省略不写时,往往表示这个维度不用考虑(意思是这个维度上“全取”,而不指定取哪个索引的元素,与:功能类似)。因此,在遇到Numpy切片操作的相关问题时,按照以上几个思路以及上述例子考虑即可。

    5.补充内容

    1.关于Numpy数组如何确定第几维的问题

    在这里,以一个例子来说明:

    b = np.arange(24).reshape(2, 3, 4)
    print(b)
    
    output:
    '''
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
    
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]
    '''
    
    print(b[0, 1, ::2])
    
    output:
    '''
    [4 6]
    '''

    例如上述例子,嵌套了三层中括号[[[…]]],在这里,最外层中括号为第一维,然后依次向里类推,最内层的括号为最后一维,因此我们执行上述切片操作时,b[0, 1, ::2],第一维取索引为0的元素,因此我们取得了

    [[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]

    这个数组,再然后考虑第二维的操作,取索引为1的元素,因此我们取得了

    [ 4  5  6  7]

    这个数组,最后一维的操作是从第0个索引开始,所有元素,每2个取一个,因此我们取得了

    [4 6]

    这个数组,也就是切片操作最后得到的结果。
    从上述分析可知,无论切片操作多复杂,维度有多高,只要我们抽丝剥茧,从最外层分析到最内层,每一维度的操作都按照要求来分析,这样的话也就不难得到最后的结果了。

    2.关于问题1中Python3中对列表进行切片操作与Numpy中对数组进行切片操作不同之处的说明

    Numpy对数组进行切片操作的代码如下:

    arr = np.arange(12)
    print('array is:')
    print(arr)
    
    slc = arr[::2]
    print('slice is:')
    print(slc)
    
    slc[0] = 999
    print('modified slice is::')
    print(slc)
    
    print('array now is::')
    print(arr)

    程序运行结果:

    array is:
    [ 0  1  2  3  4  5  6  7  8  9 10 11]
    slice is:
    [ 0  2  4  6  8 10]
    modified slice is::
    [999   2   4   6   8  10]
    array now is::
    [999   1   2   3   4   5   6   7   8   9  10  11]

    而对应的Python3对列表进行切片的代码如下:

    arr = list(range(12))
    print('array is:')
    print(arr)
    
    slc = arr[::2]
    print('slice is:')
    print(slc)
    
    slc[0] = 999
    print('modified slice is::')
    print(slc)
    
    print('array now is::')
    print(arr)

    程序运行结果:

    array is:
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    slice is:
    [0, 2, 4, 6, 8, 10]
    modified slice is::
    [999, 2, 4, 6, 8, 10]
    array now is::
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

    很明显,从以上两个程序的运行结果可以看出,切片后的变量与原始的数据共享同一数据存储。而这种特点是专门针对大数据的处理而定制的。

    3.矢量化

    在Numpy中,矢量化(vectorization)使得不用编写循环就可以对数据进行批量运算。大小相等的数组之间的任何算术运算都会将运算应用到元素级。具体例子如下:

    arr1 = np.arange(12)
    arr2 = np.arange(12)
    arr1 = arr1 / 10
    print(arr1)
    arr2 = arr2 ** 2
    print(arr2)
    print(arr1 + arr2)
    
    arr1[0:5] = 10
    print(arr1)
    
    output:
    '''
    [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.  1.1]
    [  0   1   4   9  16  25  36  49  64  81 100 121]
    [  0.    1.1   4.2   9.3  16.4  25.5  36.6  49.7  64.8  81.9 101.  122.1]
    [10.  10.  10.  10.  10.   0.5  0.6  0.7  0.8  0.9  1.   1.1]
    '''
    展开全文
  • numpy数组切片操作

    千次阅读 2017-12-19 22:00:51
    numpy 数组切片操作 关于-1的解析再来看个多维数组的情况A=np.array(range(24)) A=np.reshape(A,[4,3,2])输出:A array([[[ 0, 1], [ 2, 3], [ 4, 5]], [[ 6, 7], [ 8, 9], [10, 11]], [[1

    numpy 数组的切片操作
    关于-1的解析
    A[a : b : c], a,b表示切片的范围,c表示具体切片的方向和间隔,c=1表示left2right, c=-1表示right2left

    在这里插入图片描述

    再来看个多维数组的情况

    A=np.array(range(24))
    A=np.reshape(A,[4,3,2])
    

    输出:

    A
    array([[[ 0,  1],
            [ 2,  3],
            [ 4,  5]],
    
           [[ 6,  7],
            [ 8,  9],
            [10, 11]],
    
           [[12, 13],
            [14, 15],
            [16, 17]],
    
           [[18, 19],
            [20, 21],
            [22, 23]]])
    

    这里写图片描述

    展开全文
  • Numpy数组操作

    2020-12-21 00:05:31
    目录Numpy数组操作概述Numpy数组的创建numpy.array方法numpy.zeros方法numpy.ones方法numpy.full方法numpy.arange方法numpy.linspace方法numpy.random.random方法numpy.random.randint方法numpy.random.normal方法...
  • Python中numpy数组切片

    千次阅读 2020-07-23 16:10:01
    Python中符合切片并且常用的有:列表,字符串,元组。 下面那列表来说明,其他的也是一样的。 格式:[开头:结束:步长] 开头:当步长>0时,不写默认0。当步长<0时,不写默认-1 结束:当步长>0时,不写默认...
  • numpy数组切片操作之[:,2]、[-1:,0:2]、[1:,-1:]等都是啥? numpy数组切片操作 通过冒号分隔切片参数 start:stop:step 来进行切片操作: 形如: b = a[2:7:2] # 从索引 2 开始到索引 7 停止,间隔为 2 1 冒号 : 的...
  • 我有一个3D(时间,X,Y)numpy数组,包含6个小时的时间序列几年. (比如5).我想创建一个采样时间序列,其中包含从可用记录中随机抽取的每个日历日的1个实例(每天5种可能性),如下所示.> Jan 01:2006> Jan 02:2011&...
  • numpy数组切片操作 通过冒号分隔切片参数 start:stop:step 来进行切片操作: 冒号 : 的解释:如果只放置一个参数,如 [2],将返回与该索引相对应的单个元素。如果为 [2:],表示从该索引开始以后的所有项都将被提取。...
  • numpy数组切片

    2021-03-11 16:59:08
    numpy数组切片提供的都是数据的视图,这意味着数据不是被复制了,所有的操作都会反映在原数组上。 这样设计的原因是为了规避,复制带来的内存问题。如果所有的切片都是复制那么大量数据就会带来内存问题。 ...
  • NumPy 是一个 Python 包。 它代表 “Numeric Python”。它是一个由多维数组对象和用于处理数组的例程集合组成的库。这篇文章主要介绍了python numpy 数组的索引和切片,需要的朋友可以参考下
  • numpy 数组切片操作

    2020-02-24 17:03:54
    这两天看到numpy数组切片操作,记录一下,方便以后查看 1. 常规操作 ndarray对象的内容可以通过索引或切片来访问和修改,与 Python 中 list 的切片操作一样。 ndarray 数组可以基于 0 - n 的下标进行索引,切片...
  • # 也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作 a = np.arange(10) b = a[2:7:2] # 从索引 2 开始到索引 7 停止,间隔为 2 print(b) # [2 4 6] a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9] b =
  • Numpy数组索引与切片

    2021-10-09 06:16:41
    Numpy数组索引与切片 1. `ndarray`对象的内容可以通过`索引`或`切片`来获取和修改,就像 Python 的内置容器对象一样。 2. `一维数组`:一维数组比较简单,看起来和python列表很类似。 3. `二维数组`:每个索引值对应的...
  • numpy数组切片讲解

    2021-09-27 20:46:58
    import numpy as np a = np.array([[1.1,2.1,3.1,4.1],[5,6,7,8],[9,10,11,12]]) a 使用省略号来省略数组的参数的用法 print (a[...,1]) # 索引为1的列元素 print ('--------') print (a[1,...]) # 索引为...
  • Python中numpy 数组切片操作

    万次阅读 2018-10-17 13:45:48
    Python中numpy 数组切片操作简介取元素 X[n0,n1]切片 X[s0:e0,s1:e1]切片特殊情况 X[:e0,s1:]示例代码输出结果 简介 X[n0,n1]是通过 numpy 库引用二维数组或矩阵中的某一段数据集的一种写法。 X[n0,n1,n2]表示...
  • 1.概述今天我们来讲一下Numpy数组的索引与切片,numpy数组的索引与切片和Python中的切片与索引的作用相同,可以快速的取出数据,进行下一步的运用或者查看,但是两种切片还有一些不同的地方。另外我们可以通过数组的变形...
  • Python Numpy 数组的基本操作

    千次阅读 2019-12-30 16:19:05
    Numpy是一个通用的数组处理包。它提供了一个高性能的多维数组对象,以及处理这些数组的工具。它是Python科学计算的基本包。 Numpy除了具有科学用途外,还可以作为通用数据的高效多维容器。 Numpy中的数组 Numpy中...
  • 一. 索引 1. 普通索引 ① 一维数组索引 ② 二维数组索引 ③ 三维数组索引 2. 布尔索引 筛选时,True所对应的位置为所选...二 ....1. 一维数组切片 2. 二维数组切片 3. 三维数组切片 三. 广播 ...
  • numpy数组的索引和切片基本切片操作>>> import numpy as np>>> arr=np.arange(10)>>> arrarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])>>> arr[5]5>>> arr[5:8]array([5, 6,...
  • 一:数组的属性每个数组都有它的属性,可分为:ndim(数组的维度),shape(数组每个维度的大小),size(数组的总大小),dtype(数组数据的类型)二:数组索引和python列表一样,Numpy的索引在一维数组中,也可以通过中括号重指定...
  • 版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 ...———————————————— 版权声明:本文为CSDN博主「Activewaste」的原创文章,遵循CC 4.0 BY-SA版权协议...
  • 文章目录数组索引普通索引一维数组索引二维数组索引三维数组索引布尔索引花式索引数组切片一维数组切片二维数组切片三维数组切片数组元素重新赋值,语法,先筛选,再赋值矢量计算广播 数组索引 普通索引 一维数组索引...
  • 原标题:Python Numpy 数组的基本操作示例Numpy是一个通用的数组处理包。它提供了一个高性能的多维数组对象,以及处理这些数组的工具。它是Python科学计算的基本包。Numpy除了具有明显的科学用途外,还可以作为通用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,993
精华内容 5,997
关键字:

numpy数组切片操作