切片

目之所及，皆是回忆。心之所想，皆是往事。

1. 介绍

  在利用python解决各种实际问题的过程中，经常会遇到从某个对象中抽取部分值的情况，切片操作正是专门用于完成这一操作的有力武器。理论上而言，只要条件表达式得当，可以通过单次或多次切片操作实现任意切取目标值。切片操作的基本语法比较简单，但如果不彻底搞清楚内在逻辑，也极容易产生错误，而且这种错误有时隐蔽得比较深，难以察觉。本文通过详细例子总结归纳了切片操作的各种情况。若有错误和不足之处请大牛指正！

2. 索引方式

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

name = 'caimengzhi'
hobby = 'play game'

3. 切片方式

  一个完整的切片表达式包含两个“:”，用于分隔三个参数(start_index、end_index、step)，当只有一个“:”时，默认第三个参数step=1。

切片操作基本表达式：object[start_index:end_index:step]
                     |         |         |         |____ 步长
                     |         |         |______________ 结束索引值
                     |         |________________________ 开始索引值
                     |__________________________________ 要切片的对象                    

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

• start_index：表示起始索引（包含该索引本身）；该参数省略时，表示从对象“端点”开始取值，至于是从“起点”还是从“终点”开始，则由step参数的正负决定，step为正从“起点”开始，为负从“终点”开始。

• end_index：表示终止索引（不包含该索引本身）；该参数省略时，表示一直取到数据“端点”，至于是到“起点”还是到“终点”，同样由step参数的正负决定，step为正时直到“终点”，为负时直到“起点”。

前包后不包

4. 切片例子

下列案例已 Love_words = 'I love you forever!'

4.1 切取单个值

测试

In [1]: Love_words = 'I love you forever!'

In [2]: Love_words[0]
Out[2]: 'I'

In [3]: Love_words[3]
Out[3]: 'o'

In [4]: Love_words[2]
Out[4]: 'l'

In [5]: Love_words[1]
Out[5]: ' '

In [6]: Love_words[-1]
Out[6]: '!'

In [7]: Love_words[-2]
Out[7]: 'r'

4.2 切取完整对象

In [8]: Love_words[:]  # 从左往右
Out[8]: 'I love you forever!'

In [9]: Love_words[::] # 从左往右
Out[9]: 'I love you forever!'

In [10]: Love_words[::-1] # 从右往左
Out[10]: '!reverof uoy evol I'

4.3 起、始、步长

start_index和end_index全为正（+）索引的情况

In [16]: Love_words = 'I love you forever!'

In [17]: Love_words
Out[17]: 'I love you forever!'

In [18]: Love_words[7:10]
Out[18]: 'you'

In [20]: Love_words[7:10:1]
Out[20]: 'you'

> step=1，从左往右取值，start_index=1到end_index=6同样表示从左往右取值。步长为1的可以省略。

In [21]: Love_words
Out[21]: 'I love you forever!'

In [22]: Love_words[-8:-1:1]
Out[22]: 'forever'
> 反着取

In [36]: Love_words
Out[36]: 'I love you forever!'

In [37]: Love_words[2:7]
Out[37]: 'love '

In [38]: Love_words[:7]
Out[38]: 'I love '
In [39]: Love_words[0:7]
Out[39]: 'I love '
> 起始索引值不写就表示从0开始

In [40]: Love_words
Out[40]: 'I love you forever!'

In [41]: Love_words[11:]
Out[41]: 'forever!'

In [42]: Love_words[11:-1]
Out[42]: 'forever'

In [43]: Love_words[11:19]
Out[43]: 'forever!'
> 后面索引值不写就表示到最后

In [47]: Love_words
Out[47]: 'I love you forever!'

In [48]: Love_words[::1]
Out[48]: 'I love you forever!'

In [49]: Love_words[::2]
Out[49]: 'Ilv o oee!'
> 步长为2，从左往右取值，从start_index=0开始，一直取到终点。

start_index和end_index全为符号（-）索引的情况

In [1]: num = [i for i in range(10)]

In [2]: num
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: num[-6:-1]
Out[3]: [4, 5, 6, 7, 8]

In [4]: num[-6:-1:3]
Out[4]: [4, 7]

4.4 连续切片操作

In [3]: num = [i for i in range(10)]

In [4]: num
Out[4]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [9]: num
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [10]: num1=num[0:9]

In [11]: num1
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [12]: num2=num1[2:6]

In [13]: num2
Out[13]: [2, 3, 4, 5]

In [14]: num[0:9][2:6]
Out[14]: [2, 3, 4, 5]

理论上可无限次连续切片操作，只要上一次返回的依然是非空可切片对象。

4.5 切片表达式操作

In [19]: num
Out[19]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [20]: num[1+3:2*5:1*2]
Out[20]: [4, 6, 8]

4.6 其他对象的切片操作

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

In [22]: [1,2,3,4,5][2]
Out[22]: 3

In [23]: [1,2,3,4,5][2:5]
Out[23]: [3, 4, 5]
> 列表切片操作

In [24]: (1,2,3,4,5)[2]
Out[24]: 3

In [25]: (1,2,3,4,5)[2:5]
Out[25]: (3, 4, 5)
> 元组操作

In [26]: 'abcdefg'[::2]
Out[26]: 'aceg'
> 字符串操作

5. 常用切片操作

5.1 取偶数位置

In [34]: [i for i in range(10)]
Out[34]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [35]: [i for i in range(10)][1::2]
Out[35]: [1, 3, 5, 7, 9]

5.2 取奇数位置

In [36]: [i for i in range(10)]
Out[36]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [37]: [i for i in range(10)][::2]
Out[37]: [0, 2, 4, 6, 8]

5.3 修改单个元素

In [43]: data = [i for i in range(10)]

In [44]: data
Out[44]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> 索引值  0  1  2  3  4  5  6  7  8  9

In [45]: data[2]='ancss'

In [46]: data
Out[46]: [0, 1, 'ancss', 3, 4, 5, 6, 7, 8, 9]

5.4 在某个位置插入元素

In [47]: data = [i for i in range(10)]

In [48]: data
Out[48]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [49]: data[3]=['a','b','c','d','e']

In [50]: data
Out[50]: [0, 1, 2, ['a', 'b', 'c', 'd', 'e'], 4, 5, 6, 7, 8, 9]

In [51]: data = [i for i in range(10)]

In [52]: data[3:3]=['a','b','c','d','e']

In [53]: data
Out[53]: [0, 1, 2, 'a', 'b', 'c', 'd', 'e', 3, 4, 5, 6, 7, 8, 9]

注意插入的写法

5.5 替换一部分元素

In [38]: data = [i for i in range(10)]

In [39]: data
Out[39]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [40]: data[2:5]=['a','b','c','d','e']
>   索引值           0   1   2   3   4

In [41]: data
Out[41]: [0, 1, 'a', 'b', 'c', 'd', 'e', 5, 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:]=[0,1,2,3,4,5,6,7,8,9]，但实际上a[-1:]=a[-1]=9，
原因在于step=1表示从左往右取值，而起始索引start_index=-1本身就是对象的最右边的元素了，
再往右已经没数据了，因此只有a[-1]一个元素