Python --- 切片详解 （正负索引、索引越界、返回浅复制）（ 底层解析）
一、Python可切片对象的索引方式
列表元素支持用索引访问，正向索引从0开始
colors=["red","blue","green"]
colors[0] =="red"
colors[1]=="blue"
同时，也可以使用负向索引(python中有序序列都支持负向索引)
colors[-1]=="green"
以列表 lst = [ 'a', 'b', 'c', 'd', 'e' ] 为例
二、切片操作
[ start_index : end_index : step ]
切片适用于列表、元组、字符串、range对象等类型。由于集合、字典等无序，无法实现切片。
切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列，如：对一个列表切片返回一个列表，字符串切片返回字符串。
切片生成的子序列元素是源版的拷贝。因此切片是一种浅拷贝。
1、参数：
- start_index：表示开始索引。正索引默认为0，负索引默认为 -1。
- end_index：表示结束索引。正索引默认为列表长度 len(lst)，负索引默认为 -len(lst)。
- step：切片的步长。默认为1。正数表示从左往右切，start_index、end_index采用正索引默认值；负数表示从右往左切，start_index、end_index采用负索引默认值。（步长不能为0，否则抛出ValueError异常）
**【注意:】**切片的开始总是被包括在结果中，而结束不被包括。
即：
[0:len(lst):1] —— 开始索引为 0，结束索引为 len(lst) ，而切到的最后一个元素的索引为 len(lst)-1 ；
[-1:-len(lst):-1] —— 开始索引为-1，结束索引为 -len(lst) ，而切到的最后一个元素的索引为 -(len(lst)-1) 。
因此，切片时对象的索引可以看做下图形式：
2、参数运用的几个要点：
-
总是从 start_index 开始切取元素。
-
正索引与负索引可以混用，且 start_index 和 end_index 以及 step 不受当前列表对象的实际索引长度限制，可以认为取值是（-∞，+∞）。（切片中的越界索引会被自动处理。详见后文）
-
start到end的区间方向和step方向相反，则返回空列表
[]。#例如： >>>lst[1:4:-1] [] #返回空列表 -
start == end 时，返回空列表
[]。#例如： >>>lst[1:1:] [] #返回空列表 >>>lst[-4:-4:] [] #返回空列表
三、关于负索引
【注意:】正式句法规则并没有在序列中设置负标号的特殊保留条款。
但是，切片序列是通过__getitem__() 方法解析索引的，内置序列所提供的 getitem() 方法可通过在索引中添加序列长度来解析负标号 (这样 x[-1] 会选出 x 中的最后一项)。 结果值必须为一个小于序列中项数的非负整数，抽取操作会选出标号为该值的项（从零开始数）。 由于对负标号和切片的支持存在于对象的 getitem() 方法，重载此方法的子类需要显式地添加这种支持。
object.__getitem__(self, key)
调用此方法以实现 self[key] 的求值。对于序列类型，接受的键应为整数和切片对象。
请注意负数索引（如果类想要模拟序列类型）的特殊解读是取决于 __getitem__() 方法。
如果 key 的类型不正确则会引发 TypeError 异常；
如果为序列索引集范围以外的值（在进行任何负数索引的特殊解读之后）则应引发 IndexError 异常。
对于映射类型，如果 key 找不到（不在容器中）则应引发 KeyError 异常。
注解：for 循环在有不合法索引时会期待捕获 IndexError 以便正确地检测到序列的结束。
注意：
>>>lst[-5:] #此时，endindex默认为5，step默认为1
[a,b,c,d,e]
>>>lst[-5:-1]
[a,b,c,d]
>>>lst[-5:5] #等价于lst[-5:]
[a,b,c,d,e]
四、切片索引越界的处理
切片中的越界索引会被自动处理。
切片用于创建新列表。如果索引区间不在列表中元素数量的范围内，我们可以返回一个空列表。所以，我们不必抛出错误。
但是，如果我们直接访问列表中大于元素数量的元素,我们就不能返回任何默认值(甚至不是None，因为它可能是列表中的有效值)。这就是为什么IndexError: list index out of range在切片中被扔了。
可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。（切片索引会被静默截短到允许的范围；如果指定索引不是整数则 TypeError 会被引发。）
切片时，如果切片区间不在该对象的实际索引范围类，则将返回序列的长度设置为0，this line中
defstop = *step < 0 ? -1 : length;
...
if (r->stop == Py_None) {
*stop = defstop;
}
...
if ((*step < 0 && *stop >= *start)
|| (*step > 0 && *start >= *stop)) {
*slicelength = 0;
对于字符串，如果切片后返回的字符串长度为0，则返回空字符串，this line中
if (slicelength <= 0) {
return PyString_FromStringAndSize("", 0);
}
其他可切片对象参照以上代码，这里不再引述。
五、切片返回潜复制
切片生成一个新的序列，并且把原序列中所有元素的引用都复制到新序列中。这意味着以下切片操作会返回列表的一个 潜复制 。
Python 中赋值语句不复制对象，而是在目标和对象之间创建绑定 (bindings) 关系。对于自身可变或者包含可变项的集合对象，开发者有时会需要生成其 副本 用于改变操作，进而避免改变原对象。
Ⅰ、浅复制和深复制的区别：
1.浅复制
浅复制构造一个新的复合对象，然后(尽可能地)插入原始对象包含的相同对象。
（ 相当于原aList[0]与切片的bList[0]作为 同一个元素值的引用 共同指向第一个元素1的地址空间。）
（1）潜复制不会引发错误的情况：浅复制列表中只包含可哈希对象时（即地指定位值唯一的对象。如值类型、字符串、元组等。）
程序如下，虽然aList[0]和aList[0]共同指向第一个元素1的地址空间，但是由于1是值类型是不可变对象，因此改变aList[0] 的元素值时，不能通过 aList[0] 指针改变该地址空间的 1，只能通过指向其他地址空间来实现元素值的改变。而bList为潜复制，bList[0] 是 1 的引用（指针），bList[0]任然指向 1 的地址空间。此时潜复制没有表现出危害性。
>>>aList[1,2,3]
>>>bList = alist[:]
>>>aList[1] = 0
>>>aList
[1,0,3]
>>>bList
[1,2,3] #修改aList不影响bList
>>>aList[1,2,3]
>>>bList = aList[:]
>>>bList[0] = 0
>>>aList
[1,2,3] #修改bList也不影响aList
>>>bList
[0,2,3]
（2）潜复制会引发错误的情况：浅复制列表中包含不可哈希对象时（即可改变的对象，引用对象。如列表、字典等。）
程序如下，此时，可变对象[2]为引用类型，
- 对
[2]原地操作时，aList[1]和bList[1]始终指向对象[2]，因此原地操作修改[2]为[2,5]时，aList[1]和bList[1]都影响。 - 语句
aList[1] = [2,5]对[2]非原地操作时，根据python的内存管理[2]和[2,5]地址空间不同，为两个不同对象，aList[1]指向新元素[2,5]，bList[1]保持原状指向[2]。
无名可变对象：
>>>aList[1,[2],3] #元素[2]为无名可变对象，临时可变对象
>>>bList = aList[:]
>>>aList[1].append(5) #原地操作。注意：若不原地操作，修改前后不是同一对象。
>>>aList
[1, [2, 5], 3]
>>>bList
[1, [2, 5], 3] #修改aList的可变对象元素时，会影响bList。反之亦然。（修改不可变对象时依旧互不影响）
有名可变对象：
>>>lst = [2]
>>>aList[1,lst,3] #元素lst为可变对象
>>>bList = aList[:]
>>>lst.append(5) #原地操作。注意：若不原地操作，修改前后不是同一对象。
>>>aList
[1, [2, 5], 3]
>>>bList
[1, [2, 5], 3] #修改可变对象元素时，会同时影响aList和bList。（修改不可变对象时依旧互不影响）
可变对象非原地操作时：
>>>aList[1,[2],3] #元素[2]为无名可变对象，临时可变对象
>>>bList = aList[:]
>>>aList[1] = [2,5] #非原地操作，修改前后不是同一对象。即[2]和[2,5]地址空间不同。
>>>aList
[1, [2, 5], 3]
>>>bList
[1, [2], 3] #非原地操作，改变aList的可变对象元素，不会影响bList。反之亦然。（此时与修改非可变对象同理）
2.深复制
递归复制，存储空间独立。（消除了潜复制带来的隐患）
深复制构造一个新的复合对象，然后递归地将在原始对象中找到的对象插入到复合对象中。（ 相当于找到最终的值类型，再独立开辟空间存储一份。）
>>>import copy
>>>aList = [1,[2],3]
>>>bList = copy.deepcopy(aList) #深复制，aList和bList完全独立，互不影响
>>>aList[1].append(5) #对[2]原地操作
>>>aList
[1,[2,5],3] #修改bList不影响aList。反之亦然。(修改其他元素——可变或非可变对象 也是如此)
>>>bList
[1,[2],3]
Ⅱ、深复制存在两个问题:
- 递归对象(直接或间接保持对自身引用的复合对象)可能导致递归循环。
- 因为deep copy拷贝了所有的东西它可能拷贝了太多，例如管理数据结构甚至应该在opies之间共享。
Ⅲ、Python的深复制操作通过以下方法避免了这些问题:
-
在当前操作过程中保存已经复制的对象表。
-
让用户定义的类重写复制操作或复制的组件集。
【 不复制模块、类、函数、方法、堆栈跟踪、堆栈帧、文件、套接字、窗口、数组等类型，也不复制任何类似的类型。类可以使用与控制pickle相同的接口来控制复制:它们可以定义称为余下的getinitargs__()、余下的getstate__()和余下的setstate__()的方法。“pickle”可以获得关于这些方法的信息。】
六、切片实例：
以列表 lst = [ 'a', 'b', 'c', 'd', 'e' ] 为例
1.切取整个列表
>>>lst[::1]
['a', 'b', 'c', 'd', 'e']
2.切取倒叙的列表
>>>lst[::-1]
['e', 'd', 'c', 'b', 'a']
3.省略step以及第二个冒号
>>>lst[:] #step默认为1
['a', 'b', 'c', 'd', 'e']
4.正负索引混用
>>>lst[0:-2:1]
['a', 'b', 'c']
5.切片索引越界
>>>[-5:10:]
['a', 'b', 'c', 'd', 'e']
6.列表内的空区间
>>>lst[0:-5:]
[]
7.列表外的区间
>>>lst[5:10:]
[]
>>>lst[-5:-1:]
[]
8.start到end方向与step方向相反
>>>lst[1:3:-1]
[]
9.连续切片
>>>lst[0:4][0:3][1:4] #可无限次连续切片操作
['b', 'c']
'''
等价于
>>> x = lst[0:4]
>>> y = x[0:3]
>>> z = y[1:4]
>>> z
['b', 'c']
'''
10.参数可用多项表达式
>>>lst[2+1:3*2:7%3] # 即：a[2+1:3*2:7%3] = a[3:6:1]
['d', 'e']
11.修改多个元素
>>>lst[1:3] = ['A','B','C']
['a', 'A', 'B', 'C', 'd', 'e']
【注意:】
>>>lst[-1:] #此时step默认=1,因此end_index采用正索引默认值=len(lst)
['e']