精华内容
下载资源
问答
  • python数组切片
    2020-12-03 00:15:57

    python的数组切片操作很强大,但有些细节老是忘,故写一点东西记录下来。

    在python&numpy中切片(slice)

    对于一维数组来说,python的list和numpy的array切片操作都是相似的。无非记住

    arr[start:end:step]

    即可

    下面是几个特殊的例子

    [:]表示复制源列表

    负的index表示,从后往前。-1表示最后一个元素。

    相对于一维数组而言,二维(多维)数组用的会更多。一般语法是arr_name[行操作, 列操作]

    先随机产生一个3*4的数组

    in:arr = np.arange(12).reshape((3, 4))

    out:

    array([[ 0, 1, 2, 3],

    [ 4, 5, 6, 7],

    [ 8, 9, 10, 11]])

    取行数据

    arr[i, :] #取第i行数据

    arr[i:j, :] #取第i行到第j行的数据

    取列数据(注意数据格式)

    in:arr[:,0] # 取第0列的数据,以行的形式返回的

    out:

    array([0, 4, 8])

    in:arr[:,:1] # 取第0列的数据,以列的形式返回的

    out:

    array([[0],

    [4],

    [8]])

    取一个数据块

    取第一维的索引1到索引2之间的元素,也就是第二行

    取第二维的索引1到索引3之间的元素,也就是第二列和第三列

    in:arr[1:2, 1:3]

    out:

    array([[5, 6]])

    取第一维的全部

    按步长为2取第二维的索引0到末尾之间的元素,也就是第一列和第三列

    in: arr[:, ::2]

    out:

    array([[ 0, 2],

    [ 4, 6],

    [ 8, 10]])

    补充:数组里的-1代表倒序,而reshape里的-1代表未知!!!!!

    一个数组a=[0,1,2,3,4],a[-1]表示数组中最后一位,a[:-1]表示从第0位开始直到最后一位,a[::-1]表示倒序,从最后一位到第0位。

    更多相关内容
  • python数组切片

    2021-03-06 07:04:34
    numpy 切片In [8]: arr = np.array( [[1, 2], [3, 4]])In [9]: arrOut[9]:array([[1, 2],[3, 4]])In [10]: arr[0] # 取第一行Out[10]: array([1, 2])In [11]: arr[:, 1] # 取第二列, 用逗号隔开表示第二个切片或者...

    numpy 切片

    In [8]: arr = np.array( [[1, 2], [3, 4]])

    In [9]: arr

    Out[9]:

    array([[1, 2],

    [3, 4]])

    In [10]: arr[0] # 取第一行

    Out[10]: array([1, 2])

    In [11]: arr[:, 1] # 取第二列, 用逗号隔开表示第二个切片或者索引,就像一个tuple2,第二个切片来表示y轴

    Out[11]: array([2, 4])

    pandas 如果直接对DataFrame进行切片,只能操作行,如果还要操作列需要使用pd.DataFrame.iloc:

    In [24]: df = pd.DataFrame(data=[[1,2], [3,4]])

    In [25]:

    In [25]: df[:1]

    Out[25]:

    0 1

    0 1 2

    In [27]: df[:1] # 取第一行

    Out[27]:

    0 1

    0 1 2

    In [28]: df[:1, 1] # 如果要取列则报错,需要使用iloc

    ---------------------------------------------------------------------------

    KeyError Traceback (most recent call last)

    in

    ----> 1 df[:1, 1]

    ~/miniconda3/envs/cooka/lib/python3.7/site-packages/pandas/core/frame.py in __getitem__(self, key)

    3022 if self.columns.nlevels > 1:

    3023 return self._getitem_multilevel(key)

    -> 3024 indexer = self.columns.get_loc(key)

    3025 if is_integer(indexer):

    3026 indexer = [indexer]

    ~/miniconda3/envs/cooka/lib/python3.7/site-packages/pandas/core/indexes/range.py in get_loc(self, key, method, tolerance)

    352 except ValueError as err:

    353 raise KeyError(key) from err

    --> 354 raise KeyError(key)

    355 return super().get_loc(key, method=method, tolerance=tolerance)

    356

    KeyError: (slice(None, 1, None), 1)

    In [29]: df.iloc[:1, 1] # 使用iloc可以操作行或者列

    Out[29]:

    0 2

    Name: 1, dtype: int64

    展开全文
  • 今天小编就为大家分享一篇Python高级特性——详解多维数组切片(Slice),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Python 数组切片是否存在越界 今天在刷leetecode时注意到这个问题。 # Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None 是一道...

    Python 数组切片是否存在越界

    今天在刷leetecode时注意到这个问题。
    一道关于最小高度树的简单题

    # Definition for a binary tree node.
    class TreeNode:
         def __init__(self, x):
             self.val = x
             self.left = None
             self.right = None
    

    是一道关于最小高度树的简单题,解题思路很清晰,从root开始顺左右子树递归,不断返回中位数作为新的root直到数组为空。

    左右子树的有序数列是通过切片原数组得到的,在最初的实现中,为防止数组越界而后置了条件判断语句:

    class Solution:
        def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
            if not len(nums): 
                return 
            mid = len(nums)//2
            root = TreeNode(nums[mid]) 
            root.left = self.sortedArrayToBST(nums[:mid]) if mid > 0 else None
            root.right = self.sortedArrayToBST(nums[mid+1:]) if mid < len(nums) else None
            return root
    

    后来发现python中对数组进行切片时,例如:
    len(list) = 5,sub_list = list[4:8],返回的sub_list中实际只包含了list[4],而不是发生数组越界错误。若 sub_list[10:],则返回的是一个空list (注意,不是None)。

    故重新简化代码:

    class Solution:
        def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
            if not len(nums): 
                return 
            mid = len(nums)//2
            root = TreeNode(nums[mid]) 
            root.left = self.sortedArrayToBST(nums[:mid]) 
            root.right = self.sortedArrayToBST(nums[mid+1:])
            return root
    
    展开全文
  • 高级特性 切片操作:对list,tuple元素进行截取操作,非常简便。...以上这篇对Python 数组切片操作详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持软件开发网。 您可能感兴趣
  • Python数组切片用法详解

    千次阅读 2018-12-25 17:58:11
    Python使用过程中,经常用到切片,本文总结了一下切片的用法。

    在Python使用过程中,经常用到切片,本文总结了一下切片的用法。

    ASCII art diagram,帮助理解Python切片:

     +---+---+---+---+---+---+
     | P | y | t | h | o | n |
     +---+---+---+---+---+---+
     0   1   2   3   4   5   6
    -6  -5  -4  -3  -2  -1
    
    >>> a = ['P','y','t','h','o','n']
    >>> a[0:1]
     ['P']
    >>> a[1:3]
     ['y','t']
     
    >>> a[-2:-1]
     ['o']
    >>> a[:-1]
     ['P', 'y', 't', 'h', 'o']
    

    不带步长step参数的切片,步长默认为1:

    a[start:stop]  # 返回从stop-1开始到stop的元素
    a[start:]      # 返回从start开始的剩余部分
    a[:stop]       # 去掉最后stop个元素并返回剩余元素
    a[:]           # 复制数组a
    

    带步长step参数的切片:

    a[start:stop:step] 
    

    索引为复数的切片:

    a = ['P','y','t','h','o','n']
    a[-1]    # 返回数组中最后一个元素 -->'n'
    a[-2:]   # 返回数组中最后两个元素 -->['o', 'n']
    a[:-2]   # 去掉数组中最后两个元素并返回剩余元素 -->['P', 'y', 't', 'h']
    

    步长为复数的切片:

    a[::-1]    # 颠倒数组中的元素并返回 -->['n', 'o', 'h', 't', 'y', 'P']
    a[1::-1]   # 颠倒数组中的前两个元素并返回 -->['y', 'P']
    a[:-3:-1]  # 颠倒最后两个元素并返回 -->['n', 'o']
    a[-3::-1]  # 颠倒除最后两个元素以外的元素并返回 -->['h', 't', 'y', 'P']
    

    与slice()对象的关系:以下两种用法是相同的

    a[start:stop:step] 
    
    a[slice(start, stop, step)]
    

    与索引(index)的区别:
    ASCII art diagram 帮助理解二者区别:

                    +---+---+---+---+---+---+
                    | P | y | t | h | o | n |
                    +---+---+---+---+---+---+
    Slice position: 0   1   2   3   4   5   6
    Index position:   0   1   2   3   4   5
    
    >>> a = ['P','y','t','h','o','n']
    # 索引
    >>> a[0]
     'P'
    >>> a[5]
     'n'
    # 切片
    >>> a[0:1]
     ['P']
    >>> a[0:2]
     ['P','y']
    

    另一种理解方式:


    步长为正:

    
    >>> seq[:]                # [seq[0],   seq[1],          ..., seq[-1]    ]
    >>> seq[low:]             # [seq[low], seq[low+1],      ..., seq[-1]    ]
    >>> seq[:high]            # [seq[0],   seq[1],          ..., seq[high-1]]
    >>> seq[low:high]         # [seq[low], seq[low+1],      ..., seq[high-1]]
    >>> seq[::stride]         # [seq[0],   seq[stride],     ..., seq[-1]    ]
    >>> seq[low::stride]      # [seq[low], seq[low+stride], ..., seq[-1]    ]
    >>> seq[:high:stride]     # [seq[0],   seq[stride],     ..., seq[high-1]]
    >>> seq[low:high:stride]  # [seq[low], seq[low+stride], ..., seq[high-1]]
    

    步长为负:

    >>> seq[::-stride]        # [seq[-1],   seq[-1-stride],   ..., seq[0]    ]
    >>> seq[high::-stride]    # [seq[high], seq[high-stride], ..., seq[0]    ]
    >>> seq[:low:-stride]     # [seq[-1],   seq[-1-stride],   ..., seq[low+1]]
    >>> seq[high:low:-stride] # [seq[high], seq[high-stride], ..., seq[low+1]]
    

    参考:
    https://stackoverflow.com/questions/509211/understanding-slice-notation
    https://www.w3schools.com/python/ref_func_slice.asp
    https://www.geeksforgeeks.org/python-slice-function/

    展开全文
  • 1、数组a第0个元素(二维数组)下的所有子元素(一维数组)的第一列 import numpy as np b=np.arange(24) a=b.reshape(2,3,4) print a print a[0,:,0] 2、取所有二维数组下的每个二维数组的第0个元素(一维数组) ...
  • 如果对象是二维数组,则切片应当是x[:]的形式,里面有一个冒号,冒号之前和之后分别表示对象的第0个维度和第1个维度; 如果对象是三维数组,则切片应当是x[::],里面有两个冒号,分割出三个间隔,三个间隔的前、...
  • 代表从数组x的第1索引到第10索引(包含1,不包含10),以步长为2,切片切片结果为:[1,3,5,7,9] 每一维都有[a:b:c],由两个冒号隔开,a,b该维的索引,从a到b,不包括b。c为步长,默认为1。多维就用,逗号隔开...
  • Python多维数组切片

    千次阅读 2020-12-19 11:11:52
    2. list切片类似C数组,多维度分别用”[]“索引,单维度切片用”:“,如:>>> a[[1, 2, 3], [4, 5, 6], [7, 8, 9]]>>> a[1][1:3][5, 6]但是这样做第二个维度索引不起作用:>>> a[1:3][0:...
  • 基于维度的切片Python切片可以被用于数组,它基于每一个维度。例如有一个3x3的数组:>>> a = reshape(arange(9), (3,3))>>> print(a)[[0 1 2][3 4 5][6 7 8]]如果只使用[:]表示一个从数组开始到...
  • python数组切片含义解析

    千次阅读 2020-11-02 23:20:26
    关于数组切片的解析: ① [i]、[-1]; ② [:-1]、[:n]、[n:]、[n:m]、[:]; ③ [n: m: x]、[: : x]、[: : ]、[-1: : ]、[: -1:]、[: :-1] ④ [a,b]、[a1:a2, b1:b2] 一、一维数组 1.1 无冒号 —— 结果为一维数组的...
  • python数组切片

    千次阅读 2020-06-30 16:13:12
    数组切片[;,i] [i,:j,:k] 解释 “ .” 分隔各个维度 “:” 各个维度内的切片 1. 二维数组 import numpy as np a = np.array([[1,2,3],[4,5,6],[7,8,9]]) #<class 'numpy.ndarray'> print(a) """ ...
  • #函数:用于将多维数组左右拆分成两份 # def DvdArr(arr,n): for i in range(len(a)): for j in range(len(a[0])): a[i][j]=random.random() print("原a数组:") print(a) [b11,b12]=a[:,0:2]#按列切分,从第1...
  • python三维数组切片

    千次阅读 2021-10-18 19:58:47
    b = np.array([[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]], [[25, 26, 27, 28], [29, 30, 31, 32], [33, 34, 35,...而对于三维数组可能需要看看那个图。
  • Python-数组切片

    万次阅读 多人点赞 2018-09-23 16:07:39
    Python-数组切片 在SegmentFault上遇到一个问题,发现自己也不懂,找了资料弄懂了,翻译一下,加深印象。 本文翻译自usc.edu slicing-arrays 基于维度的切片 Python的切片可以被用于数组,它基于每一个维度。...
  • 数组切片[Python]

    2021-12-10 22:51:06
    numpy生成数组的方法 多维数组的理解 .......... (a) (b) (c) (d) 简单理解,一维数组就是一个向量,二维数组是一个矩阵,三维数组就是有几个矩阵,四维数组就是有几个这样的三维立方体,如上图,将图a...
  • 一维数组,一般[a :b],取左闭右开。若有两个冒号,即[a:b:c],则c是步长; 二维数组[a,b],a是行、b是列; 三维数组[a,b,c],a是楼层、b是行、c是列。
  • Python中numpy数组切片

    千次阅读 多人点赞 2020-07-23 16:10:01
    Python中符合切片并且常用的有:列表,字符串,元组。 下面那列表来说明,其他的也是一样的。 格式:[开头:结束:步长] 开头:当步长>0时,不写默认0。当步长<0时,不写默认-1 结束:当步长>0时,不写默认...
  • python数组切片 from numpy import array from math import log10 from matplotlib.pyplot import plot,show a=[] for i in range(1,100): a.append((i/100,log10(i/100))) a=array(a) a1=a[...,0] #切出来第一列 ...
  • python数组_Python数组

    千次阅读 2020-07-14 13:54:52
    python数组Python Array contains a sequence of data. In python programming, there is no exclusive array object because we can perform all the array operations using list. Today we will learn about ...
  • python数组求和

    千次阅读 2020-11-22 13:36:03
    广告关闭腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元!作者:dyq666,zhihu.... 本文主要内容是通过001问题来初步了解数组求和的两种常用方法。 0...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,477
精华内容 17,790
关键字:

python数组切片