Python切片透彻详解

1、python切片概述

• 在形式上，切片使用2个冒号分隔的3个数字来完成。
• 切片操作是指按照步长，截取从起始索引到结束索引，但不包含结束索引（也就是结束索引减1）的所有元素。

切片的语法表达式为：[start: end: step]

• 第一个数字start表示切片开始位置，默认为0；
• 第二个数字end表示切片截止（但不包含）位置（默认为列表长度）；
• 第三个数字step表示切片的步长（默认为1，不能为0）。
• 当start为0时可以省略，当end为列表长度时可以省略，当step为1时可以省略，省略步长时还可以同时省略最后一个冒号。
• 当step为负整数时，表示反向切片，这时start应该在end的右侧才行。

:n  代表n之前的；
::n 代表间隔为n；
n:  代表n之后的。

适用范围

• 切片方法适用于字符串、列表、元组等 ，不适用于字典；

• 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串；

• 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据；

• 字典是一个无序的集合，使用 键值对 保存数据，没有索引；

• python3支持切片操作的数据类型有list、tuple、string、unicode、range

• 切片返回的结果类型与原对象类型一致

• 切片不会改变原对象，而是重新生成了一个新的对象

2、以list为例演示切片操作

使用切片可以返回列表中部分元素组成的新列表。与使用索引作为下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。
下面是一些切片操作：（步长为正数则从左数，步长为负数则从右数；步长的符号只代表正向切片或反向切片，其绝对值才是真的步长。）

>>>  a = [1,2,3,4,5,6,7,8,9,10]
>>>  a[:]  #返回包含原列表中所有元素的新列表
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>>  a[::]  #返回包含原列表中所有元素的新列表
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>>  a[::-1] #返回包含原列表中所有元素的逆序列表
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

>>>  a[::2]  # 隔一个取一个，获取奇数位置的元素
[1, 3, 5, 7, 9]

>>>  a[1::2]  # 隔一个取一个，获取偶数位置的元素
[2, 4, 6, 8, 10]

>>>  a[100:]  #切片开始位置大于列表长度时，返回空列表
[]

>>>  a[:100]  #切片结束位置大于列表长度时，从列表尾部截断
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>>  a[-20:3]  #进行必要的截断处理
[1, 2, 3]

>>>  a[3:-10:-1]#位置3在位置-10的右侧，-1表示反向切片
[4, 3, 2]

>>>  a[3:-5]  #位置3在位置-5的左侧，步长默认为1正向切片
[4, 5]

>>>  a[7:-5]  # 步长默认为1正向切片，但这两个位置中间没有数，所以返回空列表
[]

>>>  a[2:4]  # #指定切片的开始和结束位置，下面几个和这行取数都是一样的。
[3, 4]

>>>  a[-8:-6]
[3, 4]

>>>  a[-8:4]
[3, 4]

>>>  a[2:-6]
[3, 4]

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

>>>  a[:-1] # 步长默认为1，正向切片，从起始位置到倒数最后一个，但最后一个不包含在内。
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>  a[:0]  # 步长默认为1，正向切片，从起始位置到起始位置，所以返回空列表。
[]

>>>  a[1:5:2]  # 指定切片，指定步长
[2, 4]

>>>  a[-1:0:-1]  # 步长为-1，反向切片，从倒数第一个位置，到起始位置，不包含起始位置
[10, 9, 8, 7, 6, 5, 4, 3, 2]

>>>  a[-1:1:-1]  # 步长为-1，反向切片，从倒数第一个位置，到正数索引为1的位置，不包含索引为1的位置。
[10, 9, 8, 7, 6, 5, 4, 3]

>>>  a[-1:0:-2]  # 步长为-2，反向切片，从倒数第一个位置，到起始位置，不包含起始位置.每隔2取一个数。
[10, 8, 6, 4, 2]

>>>  a[::0]  # 报错；步长不能为0
    ---------------------------------------------------------------------------

    ValueError                                Traceback (most recent call last)

    <ipython-input-17-4f1785dd46b2> in <module>()
    ----> 1 a[::0]
    

    ValueError: slice step cannot be zero

3、使用切片为列表增加元素

可以使用切片操作在列表任意位置插入新元素，不影响列表对象的内存地址，属于原地操作。

>>>  a = [3, 5, 7]
>>>  a[len(a):] = [9]       #在列表尾部增加元素
>>>  a[:0] = [1, 2]             #在列表头部插入多个元素
>>>  a[3:3] = [4]               #在列表中间位置插入元素
>>>  a
#插入后的列表：
 [1, 2, 3, 4, 5, 7, 9]

4、使用切片替换和修改

>>>  aList = [3, 5, 7, 9]
>>>  aList[:3] = [1, 2, 3]   #替换列表元素，等号两边的列表长度相等
>>>  aList
[1, 2, 3, 9]

>>>  aList[3:] = [4, 5, 6]   # 切片连续，等号两边的列表长度可以不相等
>>>  aList
[1, 2, 3, 4, 5, 6]

>>>  aList[::2] = [0]*3     # 隔一个修改一个（用三个0替换）
>>>  aList
[0, 2, 0, 4, 0, 6]

>>>  aList[::2] = ['a', 'b', 'c']   # 隔一个修改一个
>>>  aList
['a', 2, 'b', 4, 'c', 6]

>>>  aList[1::2] = range(3)    # 序列解包的用法
>>>  aList
['a', 0, 'b', 1, 'c', 2]

>>>  aList[1::2] = map(lambda x: x!=5, range(3))
>>>  aList
['a', True, 'b', True, 'c', True]

>>>  aList[1::2] = zip('abc', range(3)) # map、filter、zip对象都支持这样的用法
>>>  aList
['a', ('a', 0), 'b', ('b', 1), 'c', ('c', 2)]

>>>  aList[::2] = [1]   # 切片不连续时等号两边列表长度必须相等


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

    ValueError                                Traceback (most recent call last)

    <ipython-input-45-9d9cf1c52f51> in <module>()
    ----> 1 aList[::2] = [1]                   #切片不连续时等号两边列表长度必须相等
    

    ValueError: attempt to assign sequence of size 1 to extended slice of size 3

5、使用切片删除列表中的元素

等号右边为空！

>>>  aList = [3, 5, 7, 9]
>>>  aList[:3] = []                  #删除列表中前3个元素
>>>  aList
[9]

也可以结合使用del命令与切片结合来删除列表中的部分元素，并且切片元素可以不连续。

>>>  aList = [3, 5, 7, 9, 11]
>>>  del aList[:3]                   #切片元素连续
>>>  aList
[9, 11]

>>>  aList = [3, 5, 7, 9, 11]
>>>  del aList[::2]                  #切片元素不连续，隔一个删一个
>>>  aList
[5, 9]

6、其他对象的切片操作

(1) range( )的用法：

• range(start, stop[, step])

参数的含义：

• start: 计数从 start 开始，默认是从 0 开始。
• stop: 计数到 stop 结束，不包括 stop。
• step：步长，默认为1。
• python3中，range不是迭代器，是一个惰性可迭代对象。

>>>  [i for i in range(1,9)]
[1, 2, 3, 4, 5, 6, 7, 8]

>>>  [i for i in range(1, 9, 2)]
[1, 3, 5, 7]

>>>  [i for i in range(9, -1, -1)]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

>>>  [i for i in range(9, 0, -1)]  # 逆序，取不到括号右边的值
[9, 8, 7, 6, 5, 4, 3, 2, 1]

>>>  [i for i in range(1, 9, -1)]
[]

>>>  [i for i in reversed(range(1, 9))]  # 逆序
[8, 7, 6, 5, 4, 3, 2, 1]

(2) 字符串切片

>>>  str1 = '0123456789'
>>>  str1[::-1]
'9876543210'