精华内容
下载资源
问答
  • python切片详解
    2020-11-25 22:12:36

    先从原理上分析切片运算:

    list的切片,内部是调用__getitem__,__setitem__,__delitem__和slice函数。而slice函数又是和range()函数相关的。

    给切片传递的键是一个特殊的slice对象。该对象拥有可描述所请求切片方位的属性,例如:

    1

    2

    3

    4

    a = [1,2,3,4,5,6 ]

    x = a [1 :5 ] # x = a.__getitem__( slice (1,5, None ) )

    a [1 :3 ] = [10,11,12 ]# a.__setitem__( slice (1,3, None ), [10,11,12 ] )

    del a [1 :4 ]# a.__delitem__( slice (1,4, None ) )

    Python 的切片功能实际上比很多程序员认为的更强大。

    1

    a= m [0 :100 :10 ]# 带步进的切片(步进值=10)

    注意:步进值为step

    当step > 0 时

    切片从 start(含start)处开始,到end(不含end)处结束,**从左往右**,每隔(step-1)(索引之间的差仍为step,但相隔的元素是step-1个)个元素进行一次截取。

    这时,start 指向的位置应该在end指向的位置的左边,否则返回值为空

    当step < 0 时

    切片从 start(含start)处开始,到end(不含end)处结束,**从右往左**,每隔(step-1)(索引之间的差仍为step,但相隔的元素是step-1个)个元素进行一次截取。

    这时,start 指向的位置应该在end指向的位置的右边,否则返回值为空

    有一个经典应用是:翻转字符串

    比如:

    1

    2

    >>>str='pythontab.com'

    >>>str[::-1]

    结果为:

    'moc.batnohtyp'

    切片边界问题

    实例:

    1

    2

    3

    4

    5

    6

    s=[1,2,3,4]# S 上界为 0 下界为 4

    s[-100:100]#返回 [1,2,3,4] -100超出了上界,100超出了下界:等价于 s[0:4]

    s[-100:-200]#返回 [] -100,-200均超出了上界,自动取上界:等价于s[0:0]

    s[100:200]#返回 [] 100,200均超出了下界,自动取下界值:等价于s[4:4]

    s[:100]#返回 [1,2,3,4] 开始值省略表示从第0个开始

    s[0:]#返回 [1,2,3,4] 结束值为空表示到最后一个结束

    注意:我使用的python版本为python2.7,python的切片存在版本兼容问题。在python3中有更加高级的功能和用法,在使用时一定要注意自己的python版本。

    更多相关内容
  • Python切片详解

    2021-01-17 20:40:21
    Python切片详解       利用python解决问题的过程中,经常会遇到从某个对象中抽取部分值的情况。“切片”操作正是专门用于实现这一目标的有力武器。理论上,只要条件表达式得当,可以通过单次或多次...

    Python切片详解

          利用python解决问题的过程中,经常会遇到从某个对象中抽取部分值的情况。“切片”操作正是专门用于实现这一目标的有力武器。理论上,只要条件表达式得当,可以通过单次或多次切片操作实现任意目标值切取。切片操作的基本语法比较简单,但如果不彻底搞清楚内在逻辑,也极容易产生错误,而且这种错误有时隐蔽得较深,难以察觉。本文通过详细例子总结归纳了切片操作的各种情形,下文均以list类型作为实验对象,其结论可推广至其他可切片对象。
     

    一、 Python可切片对象的索引方式

    包括:正索引和负索引两部分,如下图所示,以list对象a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例:

    二、 Python切片操作的一般方式

    一个完整的切片表达式包含两个“:”,用于分隔三个参数(start_index、end_index、step)。当只有一个“:”时,默认第三个参数step=1;当一个“:”也没有时,start_index=end_index,表示切取start_index指定的那个元素。
    1 切片操作基本表达式:object[start_index:end_index:step]

    step:正负数均可,其绝对值大小决定了切取数据时的‘‘步长”,而正负号决定了“切取方向”,正表示“从左往右”取值,负表示“从右往左”取值。当step省略时,默认为1,即从左往右以步长1取值。“切取方向非常重要!”“切取方向非常重要!”“切取方向非常重要!”,重要的事情说三遍!

    start_index:表示起始索引(包含该索引对应值);该参数省略时,表示从对象“端点”开始取值,至于是从“起点”还是从“终点”开始,则由step参数的正负决定,step为正从“起点”开始,为负从“终点”开始。

    end_index:表示终止索引(不包含该索引对应值);该参数省略时,表示一直取到数据“端点”,至于是到“起点”还是到“终点”,同样由step参数的正负决定,step为正时直到“终点”,为负时直到“起点”

    三、 Python切片操作详细例子

    以下示例均以list对象a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例:

    1 >>>a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    1. 切取单个元素

    1 >>>a[0]
    2 >>>0
    3 >>>a[-4]
    4 >>>6
    5 当索引只有一个数时,表示切取某一个元素。

    2. 切取完整对象

    复制代码
    1 >>>a[:] #从左往右
    2 >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    3 >>>a[::]#从左往右
    4 >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    5 >>>a[::-1]#从右往左
    6 >>> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    复制代码

    3. start_index和end_index全为正(+)索引的情况

    1 >>>a[1:6]
    2 >>> [1, 2, 3, 4, 5]
    3 step=1,从左往右取值,start_index=1到end_index=6同样表示从左往右取值。
    1 >>>a[1:6:-1]
    2 >>> []
    3 输出为空列表,说明没取到数据。
    4 step=-1,决定了从右往左取值,而start_index=1到end_index=6决定了从左往右取值,两者矛盾,所以为空。
    1 >>>a[6:2]
    2 >>> []
    3 同样输出为空列表。
    4 step=1,决定了从左往右取值,而start_index=6到end_index=2决定了从右往左取值,两者矛盾,所以为空。
    1 >>>a[:6]
    2 >>> [0, 1, 2, 3, 4, 5]
    3 step=1,表示从左往右取值,而start_index省略时,表示从端点开始,因此这里的端点是“起点”,即从“起点”值0开始一直取到end_index=6(该点不包括)。
    1 >>>a[:6:-1]
    2 >>> [9, 8, 7]
    3 step=-1,从右往左取值,而start_index省略时,表示从端点开始,因此这里的端点是“终点”,即从“终点”值9开始一直取到end_index=6(该点不包括)。
    1 >>>a[6:]
    2 >>> [6, 7, 8, 9]
    3 step=1,从左往右取值,从start_index=6开始,一直取到“终点”值9。
    1 >>>a[6::-1]
    2 >>> [6, 5, 4, 3, 2, 1, 0]
    3 step=-1,从右往左取值,从start_index=6开始,一直取到“起点”0。

    4. start_index和end_index全为负(-)索引的情况

    1 >>>a[-1:-6]
    2 >>> []
    3 step=1,从左往右取值,而start_index=-1到end_index=-6决定了从右往左取值,两者矛盾,所以为空。
    4 索引-1在-6的右边(如上图)
    1 >>>a[-1:-6:-1]
    2 >>> [9, 8, 7, 6, 5]
    3 step=-1,从右往左取值,start_index=-1到end_index=-6同样是从右往左取值。
    4 索引-1在6的右边(如上图)
    1 >>>a[-6:-1]
    2 >>> [4, 5, 6, 7, 8]
    3 step=1,从左往右取值,而start_index=-6到end_index=-1同样是从左往右取值。
    4 索引-6在-1的左边(如上图)
    1 >>>a[:-6]
    2 >>> [0, 1, 2, 3]
    3 step=1,从左往右取值,从“起点”开始一直取到end_index=-6(该点不包括)。
    1 >>>a[:-6:-1]
    2 >>> [9, 8, 7, 6, 5]
    3 step=-1,从右往左取值,从“终点”开始一直取到end_index=-6(该点不包括)。
    1 >>>a[-6:]
    2 >>> [4, 5, 6, 7, 8, 9]
    3 step=1,从左往右取值,从start_index=-6开始,一直取到“终点”。
    1 >>>a[-6::-1]
    2 >>> [4, 3, 2, 1, 0]
    3 step=-1,从右往左取值,从start_index=-6开始,一直取到“起点”。

    5. start_index和end_index正(+)负(-)混合索引的情况

    1 >>>a[1:-6]
    2 >>> [1, 2, 3]
    3 start_index=1在end_index=-6的左边,因此从左往右取值,而step=1同样决定了从左往右取值,因此结果正确
    1 >>>a[1:-6:-1]
    2 >>> []
    3 start_index=1在end_index=-6的左边,因此从左往右取值,但step=-则决定了从右往左取值,两者矛盾,因此为空。
    1 >>>a[-1:6]
    2 >>> []
    3 start_index=-1在end_index=6的右边,因此从右往左取值,但step=1则决定了从左往右取值,两者矛盾,因此为空。
    1 >>>a[-1:6:-1]
    2 >>> [9, 8, 7]
    3 start_index=-1在end_index=6的右边,因此从右往左取值,而step=-1同样决定了从右往左取值,因此结果正确。

    6. 多层切片操作

    复制代码
    1 >>>a[:8][2:5][-1:]
    2 >>> [4]
    3 相当于:
    4 a[:8]=[0, 1, 2, 3, 4, 5, 6, 7]
    5 a[:8][2:5]= [2, 3, 4]
    6 a[:8][2:5][-1:] = [4]
    7 理论上可无限次多层切片操作,只要上一次返回的是非空可切片对象即可。
    复制代码

    7. 切片操作的三个参数可以用表达式

    1 >>>a[2+1:3*2:7%3]
    2 >>> [3, 4, 5]
    3 即:a[2+1:3*2:7%3] = a[3:6:1]

    8. 其他对象的切片操作

    前面的切片操作以list对象为例进行说明,但实际上可进行切片操作的数据类型还有很多,包括元组、字符串等等。

    1 >>> (0, 1, 2, 3, 4, 5)[:3]
    2 >>> (0, 1, 2)
    3 元组的切片操作
    1 >>>'ABCDEFG'[::2]
    2 >>>'ACEG'
    3 字符串的切片操作
    复制代码
    1 >>>for i in range(1,100)[2::3][-5:]: 
    2        print(i)
    3 >>>87
    4 90
    5 93
    6 96
    7 99
    8 就是利用range()函数生成1-99的整数,然后从start_index=2(即3)开始以step=3取值,直到终点,再在新序列中取最后五个数。
    复制代码

    四、 常用切片操作

    1.取偶数位置

    1 >>>b = a[::2]
    2 [0, 2, 4, 6, 8]

    2.取奇数位置

    1 >>>b = a[1::2]
    2 [1, 3, 5, 7, 9]

    3.拷贝整个对象

    复制代码
    1 >>>b = a[:] #
    2 >>>print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    3 >>>print(id(a)) #41946376
    4 >>>print(id(b)) #41921864
    5 或
    6 >>>b = a.copy()
    7 >>>print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    8 >>>print(id(a)) #39783752
    9 >>>print(id(b)) #39759176
    复制代码

    需要注意的是:[:]和.copy()都属于“浅拷贝”,只拷贝最外层元素,内层嵌套元素则通过引用方式共享,而非独立分配内存,如果需要彻底拷贝则需采用“深拷贝”方式,如下例所示:

    复制代码
     1 >>>a = [1,2,['A','B']]
     2 >>>print('a={}'.format(a))
     3 >>>b = a[:]
     4 >>>b[0] = 9 #修改b的最外层元素,将1变成9
     5 >>>b[2][0] = 'D' #修改b的内嵌层元素
     6 >>>print('a={}'.format(a))
     7 >>>print('b={}'.format(b))
     8 >>>print('id(a)={}'.format(id(a)))
     9 >>>print('id(b)={}'.format(id(b)))
    10 a=[1, 2, ['A', 'B']] #原始a
    11 a=[1, 2, ['D', 'B']] #b修改内部元素A为D后,a中的A也变成了D,说明共享内部嵌套元素,但外部元素1没变。
    12 b=[9, 2, ['D', 'B']] #修改后的b
    13 id(a)=38669128
    14 id(b)=38669192
    复制代码

    4.修改单个元素

    1 >>>a[3] = ['A','B']
    2 [0, 1, 2, ['A', 'B'], 4, 5, 6, 7, 8, 9]

    5.在某个位置插入元素

    1 >>>a[3:3] = ['A','B','C']
    2 [0, 1, 2, 'A', 'B', 'C', 3, 4, 5, 6, 7, 8, 9]
    3 >>>a[0:0] = ['A','B']
    4 ['A', 'B', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    6.替换一部分元素

    1 >>>a[3:6] = ['A','B']
    2 [0, 1, 2, 'A', 'B', 6, 7, 8, 9]

    五、 总结

    (一)start_index、end_index、step三者可同为正、同为负,或正负混合。但必须遵循一个原则,即:当start_index表示的实际位置在end_index的左边时,从左往右取值,此时step必须是正数(同样表示从左往右);当start_index表示的实际位置在end_index的右边时,表示从右往左取值,此时step必须是负数(同样表示从右往左),即两者的取值顺序必须相同。

    (二)当start_index或end_index省略时,取值的起始索引和终止索引由step的正负来决定,这种情况不会有取值方向矛盾(即不会返回空列表[]),但正和负取到的结果顺序是相反的,因为一个向左一个向右。

    (三)step的正负是必须要考虑的,尤其是当step省略时。比如a[-1:],很容易就误认为是从“终点”开始一直取到“起点”,即a[-1:]= [9, 8, 7, 6, 5, 4, 3, 2, 1, 0],但实际上a[-1:]=[9](注意不是9),原因在于step省略时step=1表示从左往右取值,而起始索引start_index=-1本身就是对象的最右边元素了,再往右已经没数据了,因此结果只含有9一个元素。

    (四)需要注意:“取单个元素(不带“:”)”时,返回的是对象的某个元素,其类型由元素本身的类型决定,而与母对象无关,如上面的a[0]=0、a[-4]=6,元素0和6都是“数值型”,而母对象a却是“list”型;“取连续切片(带“:”)”时,返回结果的类型与母对象相同,哪怕切取的连续切片只包含一个元素,如上面的a[-1:]=[9],返回的是一个只包含元素“9”的list,而非数值型“9”



    转载自 作者:马尔代夫Maldives
    链接:https://www.jianshu.com/p/15715d6f4dad

     

    展开全文
  • python 切片详解

    2020-04-11 10:31:32
    利用python解决问题的过程中,经常会遇到从某个对象中抽取部分值的情况。“切片”操作正是专门用于实现这一目标的有力武器。理论上,只要条件表达式得当,可以通过单次或多次切片操作实现任意目标值切取。切片操作的...

    写在前面:
           利用python解决问题的过程中,经常会遇到从某个对象中抽取部分值的情况。“切片”操作正是专门用于实现这一目标的有力武器。理论上,只要条件表达式得当,可以通过单次或多次切片操作实现任意目标值切取。切片操作的基本语法比较简单,但如果不彻底搞清楚内在逻辑,也极容易产生错误,而且这种错误有时隐蔽得较深,难以察觉。本文通过详细例子总结归纳了切片操作的各种情形,下文均以list类型作为实验对象,其结论可推广至其他可切片对象。

    一、 Python可切片对象的索引方式

    包括:正索引和负索引两部分,如下图所示,以list对象a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例:
    python 索引方式

    二、 Python切片操作的一般方式
    一个完整的切片表达式包含两个“:”,用于分隔三个参数(start_index、end_index、step)。当只有一个“:”时,默认第三个参数step=1;当一个“:”也没有时,start_index=end_index,表示切取start_index指定的那个元素。

    切片操作基本表达式:object[start_index:end_index:step]
    

    `step:正负数均可,其绝对值大小决定了切取数据时的‘‘步长”,而正负号决定了“切取方向”,正表示“从左往右”取值,负表示“从右往左”取值。当step省略时,默认为1,即从左往右以步长1取值。“切取方向非常重要!”“切取方向非常重要!”“切取方向非常重要!”,重要的事情说三遍!

    start_index:表示起始索引(包含该索引对应值);该参数省略时,表示从对象“端点”开始取值,至于是从“起点”还是从“终点”开始,则由step参数的正负决定,step为正从“起点”开始,为负从“终点”开始。

    end_index:表示终止索引(不包含该索引对应值);该参数省略时,表示一直取到数据“端点”,至于是到“起点”还是到“终点”,同样由step参数的正负决定,step为正时直到“终点”,为负时直到“起点”。

    三、 Python切片操作详细例子
    以下示例均以list对象a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例:

    >>>a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    

    1. 切取单个元素

    >>>a[0]
    >>>0
    >>>a[-4]
    >>>6
    当索引只有一个数时,表示切取某一个元素。
    

    2. 切取完整对象

    >>>a[:] #从左往右
    >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>>a[::]#从左往右
    >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>>a[::-1]#从右往左
    >>> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    

    3. start_index和end_index全为正(+)索引的情况

    >>>a[1:6]
    >>> [1, 2, 3, 4, 5]
    step=1,从左往右取值,start_index=1到end_index=6同样表示从左往右取值。
    
    >>>a[1:6:-1]
    >>> []
    输出为空列表,说明没取到数据。
    step=-1,决定了从右往左取值,而start_index=1到end_index=6决定了从左往右取值,两者矛盾,所以为空。
    
    >>>a[6:2]
    >>> []
    同样输出为空列表。
    step=1,决定了从左往右取值,而start_index=6到end_index=2决定了从右往左取值,两者矛盾,所以为空。
    
    >>>a[:6]
    >>> [0, 1, 2, 3, 4, 5]
    step=1,表示从左往右取值,而start_index省略时,表示从端点开始,因此这里的端点是“起点”,即从“起点”值0开始一直取到end_index=6(该点不包括)。
    
    >>>a[:6:-1]
    >>> [9, 8, 7]
    step=-1,从右往左取值,而start_index省略时,表示从端点开始,因此这里的端点是“终点”,即从“终点”值9开始一直取到end_index=6(该点不包括)
    
    >>>a[6:]
    >>> [6, 7, 8, 9]
    step=1,从左往右取值,从start_index=6开始,一直取到“终点”值9
    >>>a[6::-1]
    >>> [6, 5, 4, 3, 2, 1, 0]
    step=-1,从右往左取值,从start_index=6开始,一直取到“起点”0

    4. start_index和end_index全为负(-)索引的情况

    >>>a[-1:-6]
    >>> []
    step=1,从左往右取值,而start_index=-1到end_index=-6决定了从右往左取值,两者矛盾,所以为空。
    索引-1-6的右边(如上图)
    
    >>>a[-1:-6:-1]
    >>> [9, 8, 7, 6, 5]
    step=-1,从右往左取值,start_index=-1到end_index=-6同样是从右往左取值。
    索引-16的右边(如上图)
    
    >>>a[-6:-1]
    >>> [4, 5, 6, 7, 8]
    step=1,从左往右取值,而start_index=-6到end_index=-1同样是从左往右取值。
    索引-6-1的左边(如上图)
    
    >>>a[:-6]
    >>> [0, 1, 2, 3]
    step=1,从左往右取值,从“起点”开始一直取到end_index=-6(该点不包括)。
    
    >>>a[:-6:-1]
    >>> [9, 8, 7, 6, 5]
    step=-1,从右往左取值,从“终点”开始一直取到end_index=-6(该点不包括)。
    
    >>>a[-6:]
    >>> [4, 5, 6, 7, 8, 9]
    step=1,从左往右取值,从start_index=-6开始,一直取到“终点”。
    
    >>>a[-6::-1]
    >>> [4, 3, 2, 1, 0]
    step=-1,从右往左取值,从start_index=-6开始,一直取到“起点”。
    

    5. start_index和end_index正(+)负(-)混合索引的情况

    >>>a[1:-6]
    >>> [1, 2, 3]
    start_index=1在end_index=-6的左边,因此从左往右取值,而step=1同样决定了从左往右取值,因此结果正确
    
    >>>a[1:-6:-1]
    >>> []
    start_index=1在end_index=-6的左边,因此从左往右取值,但step=-则决定了从右往左取值,两者矛盾,因此为空
    
    >>>a[-1:6]
    >>> []
    start_index=-1在end_index=6的右边,因此从右往左取值,但step=1则决定了从左往右取值,两者矛盾,因此为空。
    
    >>>a[-1:6:-1]
    >>> [9, 8, 7]
    start_index=-1在end_index=6的右边,因此从右往左取值,而step=-1同样决定了从右往左取值,因此结果正确。
    

    6. 多层切片操作

    >>>a[:8][2:5][-1:]
    >>> [4]
    相当于:
    a[:8]=[0, 1, 2, 3, 4, 5, 6, 7]
    a[:8][2:5]= [2, 3, 4]
    a[:8][2:5][-1:] = [4]
    理论上可无限次多层切片操作,只要上一次返回的是非空可切片对象即可。
    

    7. 切片操作的三个参数可以用表达式

    >>>a[2+1:3*2:7%3]
    >>> [3, 4, 5]
    即:a[2+1:3*2:7%3] = a[3:6:1]
    

    8. 其他对象的切片操作
    前面的切片操作以list对象为例进行说明,但实际上可进行切片操作的数据类型还有很多,包括元组、字符串等等。

    >>> (0, 1, 2, 3, 4, 5)[:3]
    >>> (0, 1, 2)
    元组的切片操作
    
    >>>'ABCDEFG'[::2]
    >>>'ACEG'
    字符串的切片操作
    
    >>>for i in range(1,100)[2::3][-5:]: 
           print(i)
    >>>87
    90
    93
    96
    99
    就是利用range()函数生成1-99的整数,然后从start_index=2(即3)开始以step=3取值,直到终点,再在新序列中取最后五个数
    

    四、 常用切片操作

    1.取偶数位置

    >>>b = a[::2]
    [0, 2, 4, 6, 8]
    

    2.取奇数位置

    >>>b = a[1::2]
    [1, 3, 5, 7, 9]
    

    3.拷贝整个对象

    >>>b = a[:] #
    >>>print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>>print(id(a)) #41946376
    >>>print(id(b)) #41921864>>>b = a.copy()
    >>>print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>>print(id(a)) #39783752
    >>>print(id(b)) #39759176
    

    需要注意的是:[:]和.copy()都属于“浅拷贝”,只拷贝最外层元素,内层嵌套元素则通过引用方式共享,而非独立分配内存,如果需要彻底拷贝则需采用“深拷贝”方式,如下例所示:

    >>>a = [1,2,['A','B']]
    >>>print('a={}'.format(a))
    >>>b = a[:]
    >>>b[0] = 9 #修改b的最外层元素,将1变成9
    >>>b[2][0] = 'D' #修改b的内嵌层元素
    >>>print('a={}'.format(a))
    >>>print('b={}'.format(b))
    >>>print('id(a)={}'.format(id(a)))
    >>>print('id(b)={}'.format(id(b)))
    a=[1, 2, ['A', 'B']] #原始a
    a=[1, 2, ['D', 'B']] #b修改内部元素A为D后,a中的A也变成了D,说明共享内部嵌套元素,但外部元素1没变。
    b=[9, 2, ['D', 'B']] #修改后的b
    id(a)=38669128
    id(b)=38669192
    

    4.修改单个元素

    >>>a[3] = ['A','B']
    [0, 1, 2, ['A', 'B'], 4, 5, 6, 7, 8, 9]
    

    5.在某个位置插入元素

    >>>a[3:3] = ['A','B','C']
    [0, 1, 2, 'A', 'B', 'C', 3, 4, 5, 6, 7, 8, 9]
    >>>a[0:0] = ['A','B']
    ['A', 'B', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    

    6.替换一部分元素

    >>>a[3:6] = ['A','B']
    [0, 1, 2, 'A', 'B', 6, 7, 8, 9]
    

    五、 总结
    (一)start_index、end_index、step三者可同为正、同为负,或正负混合。但必须遵循一个原则,即:当start_index表示的实际位置在end_index的左边时,从左往右取值,此时step必须是正数(同样表示从左往右);当start_index表示的实际位置在end_index的右边时,表示从右往左取值,此时step必须是负数(同样表示从右往左),即两者的取值顺序必须相同。

    (二)当start_index或end_index省略时,取值的起始索引和终止索引由step的正负来决定,这种情况不会有取值方向矛盾(即不会返回空列表[]),但正和负取到的结果顺序是相反的,因为一个向左一个向右。

    (三)step的正负是必须要考虑的,尤其是当step省略时。比如a[-1:],很容易就误认为是从“终点”开始一直取到“起点”,即a[-1:]= [9, 8, 7, 6, 5, 4, 3, 2, 1, 0],但实际上a[-1:]=[9](注意不是9),原因在于step省略时step=1表示从左往右取值,而起始索引start_index=-1本身就是对象的最右边元素了,再往右已经没数据了,因此结果只含有9一个元素。

    (四)需要注意:“取单个元素(不带“:”)”时,返回的是对象的某个元素,其类型由元素本身的类型决定,而与母对象无关,如上面的a[0]=0、a[-4]=6,元素0和6都是“数值型”,而母对象a却是“list”型;“取连续切片(带“:”)”时,返回结果的类型与母对象相同,哪怕切取的连续切片只包含一个元素,如上面的a[-1:]=[9],返回的是一个只包含元素“9”的list,而非数值型“9”。

    展开全文
  • Python切片对象的索引方式 切片的参数 step:正负数均可,其绝对值大小决定了切取数据时的‘‘步长”,而正负号决定了“切取方向”,正表示“从左往右”取值,负表示“从右往左”取值。当step省略时,默认为1,...

    目录

    切片

    作用:处理列表的部分元素

    用切片复制列表

     Python可切片对象的索引方式

    切片的参数

     step:正负数均可,其绝对值大小决定了切取数据时的‘‘步长”,而正负号决定了“切取方向”,正表示“从左往右”取值,负表示“从右往左”取值。当step省略时,默认为1,即从左往右以步长1取值。

    [a::-1]的使用

    [:b:-1]的使用

    [::-1] 的使用


     

    切片

    作用:处理列表的部分元素

    代码:

    list=[1,2,3,4,5,6,7,8,9]
    print(list[1:5])

     

    输出:

    [2, 3, 4, 5]

    特点:左闭右开,[1:5]代表索引1、2、3、4的元素。

    如果没有指定第一个参数,自动从头开始。

    代码:

    list=[1,2,3,4,5,6,7,8,9]
    print(list[:5])

     

    输出:

    [1, 2, 3, 4, 5]

    同理如果没有指定第二个参数,自动到末尾结束。


    用切片复制列表

    那么如何用切片复制一个列表呢?

     

    代码:

    list=[1,2,3,4,5,6,7,8,9]
    list_1=list[2:5]
    print(list)
    print(list_1)

     

    输出:

    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    [3, 4, 5]

    当我们复制列表不用切片,而直接赋值时:

    list=['cat','dog','pig']
    list_1=list
    list.append('1')
    list_1.append('2')
    print(list)
    print(list_1)

     

    输出:

    ['cat', 'dog', 'pig', '1', '2']
    ['cat', 'dog', 'pig', '1', '2']

    原本我们想得到的结果是在list列表中加上1,在list_1列表中加上2,然而得到的结果却是相同的。

    这是因为这样实际上是让python将新变量(也就是list_1)关联原来的列表。当你用list_1列表或原来的list列表时实际上指向的是同一个列表。


     Python可切片对象的索引方式

    包括:正索引和负索引两部分,如下图所示,以list对象a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例:

     下面以实例说明负索引的使用:

    list=[1,2,3,4,5,6,7,8,9]
    print(list[:-4])

     

    输出:

    [1, 2, 3, 4, 5]

     

    [:-4]代表着索引为0、1、2、3、4的元素,也就是从第一个元素到倒数第5个。


    切片的参数

    切片操作基本表达式:object[start_index:end_index:step]

     step:正负数均可,其绝对值大小决定了切取数据时的‘‘步长”,而正负号决定了“切取方向”,正表示“从左往右”取值,负表示“从右往左”取值。当step省略时,默认为1,即从左往右以步长1取值。

    step为正数时

    代码:

    list=[1,2,3,4,5,6,7,8,9]
    print(list[:6:2])

     

     输出:

    [1, 3, 5]

     step=2代表从头开始每隔2个元素取一次值。

    step为负数时

    代码:

    list=[1,2,3,4,5,6,7,8,9]
    print(list[1:6:-1])

     

    输出:

    []

     输出为空列表,说明没取到数据,这是因为step=-1,决定了从右往左取值,而start_index=1到end_index=6决定了从左往右取值,两者矛盾,所以没有取到值。


    [a::-1]的使用

    代码:

    list=[1,2,3,4,5,6,7,8,9]
    print(list[4::-1])

     

    输出:

    [5, 4, 3, 2, 1]

     当step为负数时,end_index默认为第一个数,所以从右往左取值,从start_index=4开始,一直取到“起点”1。

    [:b:-1]的使用

    代码:

    list=[1,2,3,4,5,6,7,8,9]
    print(list[:4:-1])

     

     输出:

    [9, 8, 7, 6]

     当step为负数时,start_index默认为最后一个数,所以从右往左取值,从“终点”值9开始,一直取到end_index=4(不包括该点)。

    [::-1] 的使用

    代码:

    list=[1,2,3,4,5,6,7,8,9]
    print(list[::-1])

     

    输出:

    [9, 8, 7, 6, 5, 4, 3, 2, 1]

     当start_index和end_index都不传入值时,而step为负,那么start_index默认为最后一个数,end_index默认为第一个数,所以从最后一个数从右往左取值一直到第一个数。

     

    下面我们以一道题来说明:

    编写函数, 接收一个列表(包含10个整形数)和一个整形数k, 返回一个新列表.
         函数需求:
            - 将列表下标k之前对应(不包含k)的元素逆序;
            - 将下标k及之后的元素逆序;

    代码:

    def fun (list,k):
    	if k<0 or k>len(list):
    		return 'Error'
    	else:
    		list1=list[k:]
    		list2=list1[::-1]
    		list3=list[:k]
    		list4=list3[::-1]
    		return list4+list2
    list=[1,2,3,4,5,6,7,8,9,10]
    print(list)
    print(fun(list,3))

    输出:

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

    展开全文
  • 先从原理上分析切片运算:list的切片,内部是调用__getitem__,__setitem__,__delitem__和slice函数。而slice函数又是和range()函数相关的。给切片传递的键是一个特殊的slice对象。该对象拥有可描述所请求切片方位的...
  • 该参数省略时,表示一直取到数据“端点”,至于是到“起点”还是到“终点”,同样由step参数的正负决定,step为正时直到“终点”,为负时直到“起点” 三、 Python切片操作详细例子 以下示例均以list对象a = [0, 1, ...
  • 详解Python 切片语法

    2020-12-26 02:51:44
    Python切片是特别常用的功能,主要用于对列表的元素取值。使用切片也会让你的代码显得特别Pythonic。 切片的主要声明如下,假设现在有一个list,命名为alist: alist = [0,1,2,3,4] 切片语法的基本形式为: alist...
  • 先从原理上分析切片运算:list的切片,内部是调用__getitem__,__setitem__,__delitem__和slice函数。而slice函数又是和range()函数相关的。给切片传递的键是一个特殊的slice对象。该对象拥有可描述所请求切片方位的...
  • Python 切片语法详解

    2020-11-25 22:12:39
    基础概念Python切片是特别常用的功能,主要用于对列表的元素取值。使用切片也会让你的代码显得特别Pythonic。切片的主要声明如下,假设现在有一个list,命名为alist:alist = [0,1,2,3,4]复制代码切片语法的基本...
  • Python切片透彻详解

    2020-08-04 00:58:04
    文章目录1、python切片概述2、以list为例演示切片操作3、使用切片为列表增加元素4、使用切片替换和修改5、使用切片删除列表中的元素6、其他对象的切片操作 1、python切片概述 在形式上,切片使用2个冒号分隔的3个...
  • 主要介绍了Python中字符串切片操作 的相关资料,需要的朋友可以参考下
  • 今天小编就为大家分享一篇对Python 数组的切片操作详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 在利用python解决各种实际问题的过程中,经常会遇到从某个对象中抽取部分值的情况,切片操作正是专门用于完成这一操作的有力武器。理论上而言,只要条件表达式得当,可以通过单次或多次切片操作实现任意切取目标值。...
  • 文章目录一、Python切片实例二、Python两套索引三、切片理解1. 切片基本逻辑2. 正、逆序不同之处四、深层原理 一、Python切片实例 下面以字符串对象 str1 为例进行切片操作. #!/usr/bin/env python3 # encoding:utf-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,782
精华内容 2,712
关键字:

python切片详解