python切片详解

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

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就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。注意，返回的序列从开始位置开始 ，刚好在 结束 位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。

这样，shoplist[1:3]返回从位置1开始，包括位置2，但是停止在位置3的一个序列切片，因此返回一个含有两个项目的切片。类似地，shoplist[:]返回整个序列的拷贝。shoplist[::3]返回位置3，位置6，位置9…的序列切片。

你可以用负数做切片。负数用在从序列尾开始计算的位置。例如，shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片，shoplist[::-1]会返回倒序序列切片。

使用Python解释器交互地尝试不同切片指定组合，即在提示符下你能够马上看到结果。序列的神奇之处在于你可以用相同的方法访问元组、列表和字符串。

Python中含有六种内建序列类：list, tuple, string, unicode, buffer, xrange。其中xrange比较特殊，它是一个生成器，其他几个类型具有的一些序列特性对它并不适合。

[python]  view plain  copy

 print ?

1. >>> a = 'Iloveyou'   
2. >>> len(a)   
3. 8   
4. >>> max(a)   
5. 'y'   
6. >>> min(a)   
7. 'I'   
8. >>> bool('o' in a)   
9. True   
10. >>> a + a   
11. 'IloveyouIloveyou'   
12. >>> a*3   
13. 'IloveyouIloveyouIloveyou'   
14. >>> a[1:4]   
15. 'lov'   
16. >>> a.index('y')   
17. 5   
18. >>> a[5]   
19. 'y'   

一般说来，具有序列结构的数据类型都可以使用：index, len, max, min, in, +, *, 切片。如：

切片操作

对于具有序列结构的数据来说，切片操作的方法是：consequence[start_index: end_index: step]。

start_index：表示是第一个元素对象，正索引位置默认为0；负索引位置默认为 -len(consequence)

end_index：表示是最后一个元素对象，正索引位置默认为 len(consequence)－1；负索引位置默认为 -1。

step：表示取值的步长，默认为1，步长值不能为0。

［注意］对于序列结构数据来说，索引和步长都具有正负两个值，分别表示左右两个方向取值。索引的正方向从左往右取值，起始位置为0；负方向从右往左取值，起始位置为-1。因此任意一个序列结构数据的索引范围为 -len(consequence) 到 len(consequence)-1 范围内的连续整数。

切片操作会将按照给定的索引和步长，截取序列中由连续的对象组成的片段，单个索引返回值可以视为只含有一个对象的连续片段。

切片的过程是从第一个想要的对象开始，到第一个不想要的对象结束。第一个想要的对象到第一个不想要的对象之间的连续对象就是你所有想要的对象。

因此在consequence[start_index: end_index]中，切片中包含了consequence[start_index]，但不包括consequence[end_index]。

切片的操作类型：

con[start_index]：返回索引值为start_index的对象。start_index为 -len(con)到len(con)-1之间任意整数。

con[start_index: end_index]：返回索引值为start_index到end_index－1之间的连续对象。

con[start_index: end_index : step]：返回索引值为start_index到end_index-1之间，并且索引值与start_index之差可以被step整除的连续对象。

con[start_index: ]：缺省end_index，表示从start_index开始到序列中最后一个对象。

con[: end_index］：缺省start_index，表示从序列中第一个对象到end_index-1之间的片段。

con[:]：缺省start_index和end_index，表示从第一个对象到最后一个对象的完整片段。

con[::step]：缺省start_index和end_index，表示对整个序列按照索引可以被step整除的规则取值。

在使用单索引对序列寻址取值时，你所输入的索引值必须是处于 -len(consequence) 到 len(consequence)-1 之间的值，否则会报错提示索引值超出范围。如：

[python]  view plain  copy

 print ?

1. >>> a=[1,2,3,4,5,6,7]   
2. >>> a[len(a)-1]   
3. 7   
4. >>> a[-len(a)]   
5. 1   
6. >>> a[len(a)]   
7.     
8. Traceback (most recent call last):   
9.   File "<pyshell#98>", line 1, in <module>   
10.     a[len(a)]   
11. IndexError: list index out of range   
12. >>> a[-len(a)-1]   
13.     
14. Traceback (most recent call last):   
15.   File "<pyshell#99>", line 1, in <module>   
16.     a[-len(a)-1]   
17. IndexError: list index out of range   

其中a[len(a)-1]等同于a[-1]，a[-len(a)]等同于a[0]，分别表示序列的最后一个和第一个对象。

当使用冒号(:)对序列进行切片取值时，你所输入的无论是start_index或者end_index，都不必局限于 -len(a) 和 len(a)-1 之间，因为只有当你输入的索引号处于这个区间时才真正有效，而当你输入的索引号超出这个范围时，python会自动将start_index或end_index设定为缺省值（即第一个对象和最后一个对象）。如：

[python]  view plain  copy

 print ?

1. >>> a[-100:100]   
2. [1, 2, 3, 4, 5, 6, 7]   

［注意］一定要记住，end_index其实是你第一个不想要获取的对象的索引，所以a[0:-1]是取不到a[-1]的，所以如果要使得切片片段包含end_index位置的对象，请缺省end_index，或者输入一个超出end_index范围的值。

利用步长对序列进行倒序取值

在切片运算中，步长为正，表示从左至右，按照索引值与起始位置索引之差可以被步长整除的规律取值；当步长为负，则表示从右至左，按照按照索引值与起始位置索引之差可以被步长整除的规律取值。

根据这个特性，我们可以很方便对某个序列进行倒序取值，这个方法比reverse方法更方便，且适用于没有reverse方法的字符串和元组。

[python]  view plain  copy

 print ?

1. >>> a=[1,2,3,4,5,6,7]   
2. >>> b=(1,2,3,4,5,6,7)   
3. >>> c='Let me show you a little thing'   
4. >>> a[::-1]   
5. [7, 6, 5, 4, 3, 2, 1]   
6. >>> b[::-1]   
7. (7, 6, 5, 4, 3, 2, 1)   
8. >>> c[::-1]   
9. 'gniht elttil a uoy wohs em teL'   
10. >>> a   
11. [1, 2, 3, 4, 5, 6, 7]   
12. >>> b   
13. (1, 2, 3, 4, 5, 6, 7)   
14. >>> c   
15. 'Let me show you a little thing'   
16.     
17. >>> a.reverse()   
18. >>> a   
19. [7, 6, 5, 4, 3, 2, 1]   

相对reverse而言，切片的方法不会改变列表的结构，所以这是在实际应用中比较有用的一个技巧。

参考

[1]http://blog.csdn.NET/werm520/article/details/7617376

[2]http://developer.51cto.com/art/201304/389771.htm

=================================================================================================================