>>>a[6::-1]
>>> [6, 5, 4, 3, 2, 1, 0]
step=-1，从右往左取值，从start_index=6开始，一直取到“起点”0。
                
4. start_index和end_index全为负（-）索引的情况
                
>>>a[ : : -1]    # step为负时，默认是终止值到起始值，即[终止值 : 起始值 : -1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
                  
>>>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同样是从右往左取值。
索引-1在6的右边（如上图）
                  
>>>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)
就是利用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()都属于“浅拷贝”，只拷贝最外层元素，内层嵌套元素则通过引用方式共享，而非独立分配内存，如果需要彻底拷贝则需采用“深拷贝”方式
                
4.修改单个元素
                  
>>>a[3] = ['A','B']
[0, 1, 2, ['A', 'B'], 4, 5, 6, 7, 8, 9]
                
5.利用切片在某个位置插入元素
                  
>>>a[3:3] = ['A','B','C']   # 如果给切片赋值列表，则类似列表的extend方法
[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]
                
>>>a[ : : 2] = ['a','b','c','d','e']            # 赋值个数必须与切片个数一致
['a',  1,  'b',  3,  'c',  5,  'd',  7,  'e',  9]
>>>a[ : : -2] = ['a','b','c','d','e']
[0 , 'e' ,  2 , 'd' , 4 , 'c' , 6 , 'b' , 8 , 'a']
                
四、 总结
                
（一）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”。
            
四、列表的赋值与拷贝（课外阅读）

            
详情请参阅：https://blog.csdn.net/as480133937/article/details/87305247
            
一、可变与不可变数据类型
              这两者最本质的区别在于：可变不可变是指内存中的那块内容（值）是否可以被改变

            
（1）不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，就是不可变数据类型引用的地址的值不可改变
            
改变对象的值，其实是引用了不同的对象 ，如下图：

            
（2）可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址不会改变，只是对应地址的内容改变或者地址发生了扩充，所以对于相同的值的不同对象，会存在多份，即每个对象都有自己的地址
            
列表的 * = 和 + =则在原地修改列表
注意：给列表赋值的情况（用id函数发现内存地址已变）
            
二、引用赋值
            
用“=”进行引用复制时，只是会给现存的对象添加一个新的引用，并不会在内存中生成新的对象,例如：
            
三、浅拷贝（shallow copy）
            
浅拷贝有三种形式：切片操作，工厂函数，copy模块中的copy函数。
            
1、切片操作：b = a[:] 或者 b = [each for each in a]
            
2、工厂函数：b = list(a)
            
3、copy函数：b = copy.copy(a) 或者 b=a.copy() 或者 b=list.copy(a)
            
浅拷贝 只拷贝父对象(一层)，不会拷贝对象的内部的可变子对象(多层)。浅拷贝是指拷贝的只是原子对象元素的引用。
            
list1 = ["tom",18,["play","sleep"]]
# 以下三种方法都属于浅拷贝
# 1.使用copy()的方法。
list2 = list1.copy()

# 2.使用切片的方法。
list3 = list1[:]
# 3.使用list函数
list4 = list(list1)
          
四、深拷贝（deep copy）
          
深拷贝只有一种形式，copy模块中的deepcopy函数。
          
和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。
          
深拷贝出来的对象根本就是一个全新的对象，不再与原来的对象有任何关联。
          
list1 = ["tom",18,["play","sleep"]]

# 深copy的方法
import copy
list2 = copy.deepcopy(list1)
五、深、浅copy的区别
深、浅copy主要区别就是在复制内部元素的可变数据类型方面。
浅copy对可变数据类型是共用一份内存地址，没有完全将原值和copy的值内存地址分开。当对可变数据类型进行改的时候，两者都会改变。
深copy则将可变数据类型存放的内存地址重新申请了一份内存空间，将两者完全分开。对可变数据类型进行改的时候，两者不会一起改变。