列表的索引和切片
列表是序列类型中的可变类型，它的索引和切片操作，和通用的序列操作比较，有许多不一样的地方，主要体现在利用索引和切片对列表元素进行增、删、改。
索引和切片是序列类型通用操作，详细的规则和用法，见序列索引和切片。
列表可以利用索引替换某一个元素：
_list = [1,2,3]
_list[1] = 0
_list

[1, 0, 3]

利用切片将切片中的元素替换为可迭代对象中的元素：
_list = [1,2,3]
_list[1:3] = '123'
_list

[1, '1', '2', '3']

# 该替换,切片长度和可迭代对象长度必须相等
_list = [1,2,3,4,5]
_list[1:5:2] = '24'
_list

[1, '2', 3, '4', 5]

需要注意，替换并没有改变原来的列表对象：
list_1 = [1,2,3]
print(id(list_1),list_1)
list_1[2] = 0
print(id(list_1),list_1)
list_1[:] = range(5)
print(id(list_1),list_1)
list_1[::2] = ('a','b','c')
print(id(list_1),list_1)

2065281773704 [1, 2, 3]
2065281773704 [1, 2, 0]
2065281773704 [0, 1, 2, 3, 4]
2065281773704 ['a', 1, 'b', 3, 'c']

可以利用切片在列表中任意位置插入数据片段：
_list = [1,2,3]
# 在前面插入两个 0
_list[:0] = (0,0)
print(_list)
# 在索引为 2 的元素前面插入 'a','b'
_list[2:2] = ['a','b']
_list

[0, 0, 1, 2, 3]





[0, 0, 'a', 'b', 1, 2, 3]

列由切片浅拷贝列表，生成新的列表，但列表中有可变对象时，新列表中的可变对象和对应的原来列表中的可变对象是同一个对象的多次引用：
list_1 = [[1,2],3,4]
list_2 = list_1[:]
print('原列表：',id(list_1),'新列表：',id(list_2))
print('原列表中的可变对象：',
      id(list_1[0]),
      '\n新列表中对应的可变对象：',id(list_2[0]))

原列表： 2065281774536 新列表： 2065281774664
原列表中的可变对象： 2065281383112 
新列表中对应的可变对象： 2065281383112

改变其中一个，都会跟着改变。需要注意区分修改列表中元素的元素，和修改列表元素的区别：
list_1[0][0] = 'a'
print(list_1, list_2)
list_1[0] = 'a'
print(list_1, list_2)

[['a', 2], 3, 4] [['a', 2], 3, 4]
['a', 3, 4] [['a', 2], 3, 4]

列表的索引和切片
1.列表
定义：①可变的数据类型

②数据类型不限

③多个值用逗号（，）隔开

列表eg：
list1=[1,2,3,'zhangqiaomiao']
print(list1)

二维列表（列表中的元素可以用列表表示）

eg：
list2=[[1,2,3], [4,5,6], ['zhangqiaomiao','weihailang']]
print(list2)

2.列表的索引和切片：
索引：有序的列表中的元素都有其唯一对应的索引值，所有的索引值都是从0开始的，利用索引值进行索引和切片。

列表[开始:终止:步长] 半开区间, 开始的位置包含在内, 而终止的位置不包含在内

步长的默认值为1, 当步长设置为负整数, 代表, 从后往前切

开始和终止, 如果不填, 代表一直到头
list5 = ['零', '一', '二', '三', '四', '五', '六']
print(list5[0])
零

print(list5[::-1])
['六', '五', '四', '三', '二', '一', '零']

print(list5[0:6])      #不包含第6个索引值的元素,步长未填写  默认为1
['零', '一', '二', '三', '四', '五']

print(list5[0:7:1])    #包含第6个索引值的元素，步长为1
['零', '一', '二', '三', '四', '五', '六']

print(list5[::2])      #开始和终止未填写代表从最开始一直检索到最后的值，步长为2
['零', '二', '四', '六']

3.二维列表的索引和切片
二维列表eg:
list6 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]   #可以将列表中列表当成一个元素，总共有3个元素
print(list6[0])   #打印list6中的第0个索引值的元素
[1, 2, 3]

print(list6[0][0])    #打印出list6中的第0个索引值的元素（是列表[1,2,3]）列表中第0个索引值的元素
1

print(list6[2][-2])    #打印出list6中的第2个索引值的元素（是列表[7,8,9]）列表中倒数第2个索引值的元素
8

print(list6[1][2:0:-1])   #打印出list6中的第1个索引值的元素（是列表[4,5,6]）列表中从第0个索引值开始到第2个索引值，并从后往前切
[6, 5]

4.更改列中中的值
eg：
list7 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
#练习：将list7中的2变成1+1
list7[0][-2]='1+1'
print(list7)
[[1, '1+1', 3], [4, 5, 6], [7, 8, 9]]

课后练习题：
test = [[‘python’, ‘C’, ‘C++’, ‘Java’], [‘Ruby’, ‘R’, ‘shell’], [‘go’, ‘Scala’]]

1.索引出C++, 索引出 R #

2.索引出(C++ 和 Java) #

3.把列表中的go改成大写 #

4.把python 和 C 的大小写进行交换
test = [['python', 'C', 'C++', 'Java'], ['Ruby', 'R', 'shell'], ['go', 'Scala']]
#1.1索引出c++
print(test[0][2])   
C++

#1.2索引出R
print(test[1][1])    
R

#2.1索引出c++和java
print(test[0][2:4:1])    
['C++', 'Java']

#3.将列表中的go换成GO
test[2][0]='GO'
print(test)     
[['python', 'C', 'C++', 'Java'], ['Ruby', 'R', 'shell'], ['GO', 'Scala']]

#4.将python和C中的大小写进行交换
test[0][0]='PYTHON'
test[0][1]='c'
print(test)    
[['PYTHON', 'c', 'C++', 'Java'], ['Ruby', 'R', 'shell'], ['GO', 'Scala']]

在python中的列表类型可以往里面加入各种对象的元素。
列表类型中索引和切片
在【list】也可以进行索引和切片，不过是以元素为单位的，而不是以字符为单位。
在切片中，索引序号也是从0开始的
>>>a =  ['2',3,'make']
>>>a
['2',3,'make']
a[0]  #索引序号从0开始
'2'
>>>a[2]
'make'
>>>a[:2]  #跟Str中的类似，切片的范围是：包含开始位置，到结束位置之前。
[2,3]  #不包含结束位置
a[1:]  #从开始位到最后一位
[3,'make']
>>>a[2][1:3]  #可以对列表中的元素做2次切片
'ak'  #2次切片，a中的序号2位元素中的序号1到序号2位字符。
list和str两种类型的数据，有共同的地方，它们都属于序列(都是一些对象按照某个次序排列起来，着就是序列的最大的特征)
因此，有很多类似的地方。比如，索引和切片。
>>>lang = "python"
>>>lang.index("y")  #表示字符"y"在lang中序列号是多少。
1
>>>lst = ['python','java','c++']
>>>lst.index('java')  #表示java这个元素在lst列表中的序列号是多少。
1
以上做展示的字符串串索引和切片，都是从左边开始的。
反向索引
还有一种编号方式，就是从右边开始，右边第一个编号为-1，然后依次是-2，-3，...,依次类推下来。
这对字符串，列表等各种序列类型都适用。
>>>lang = "python"
>>>lang[-1]
'n'
>>>lang[-3]
'h'
>>>lst = ['python','java','c++']
lst[-2]
'java'
从右边开始编号，第-1号是右边第一个。
但是要切片的话，一定要遵循左边数字小于右边的数字。
例如：
lang = ;python'
lang[-3:-1]
'ho'
lst = ['python','java','c++']
lst[-3:-1]
['python','java']
在反向序列中的切片，同样遵循原则是：到包含开始位置，到结束位置之前。
反转
>>>ls = [1,2,3,4,5,6]
ls[::-1]  #反转
[6,5,4,3,2,1]
>>>ls
[1,2,3,4,5,6]  #ls的对象数据没有变化，只是用函数让元素反向排列了。
对字符串同样也可以
>>>lang = 'python'
lang[::-1]
'nohtyp'
>>>lang
'python'
上面的反转，不管是int类型还是lst类型反转之后，原来的值都没有改变。
在python中用函数将序列类型反转。
>>> ls = [1,2,3,4,5,6,7,8]
>>> ls
[1, 2, 3, 4, 5, 6, 7, 8]
>>> list(reversed(ls))
[8, 7, 6, 5, 4, 3, 2, 1]
用【list(reversed(object))】函数可以返回反转的序列.
它返回的对象也是可以迭代的，不过是已经将原来的序列对象反转了。
如下：
>>>list(reversed('abcd'))
['d','c','b','a']
关于列表的操作就暂时就这么多了。

在python中的列表类型可以往里面加入各种对象的元素。
列表类型中索引和切片
在【list】也可以进行索引和切片，不过是以元素为单位的，而不是以字符为单位。
在切片中，索引序号也是从0开始的
>>>a =  ['2',3,'make']
>>>a
['2',3,'make']
a[0]  #索引序号从0开始
'2'
>>>a[2]
'make'
>>>a[:2]  #跟Str中的类似，切片的范围是：包含开始位置，到结束位置之前。
[2,3]  #不包含结束位置
a[1:]  #从开始位到最后一位
[3,'make']
>>>a[2][1:3]  #可以对列表中的元素做2次切片
'ak'  #2次切片，a中的序号2位元素中的序号1到序号2位字符。
list和str两种类型的数据，有共同的地方，它们都属于序列(都是一些对象按照某个次序排列起来，着就是序列的最大的特征)
因此，有很多类似的地方。比如，索引和切片。
>>>lang = "python"
>>>lang.index("y")  #表示字符"y"在lang中序列号是多少。
1
>>>lst = ['python','java','c++']
>>>lst.index('java')  #表示java这个元素在lst列表中的序列号是多少。
1
以上做展示的字符串串索引和切片，都是从左边开始的。
反向索引
还有一种编号方式，就是从右边开始，右边第一个编号为-1，然后依次是-2，-3，...,依次类推下来。
这对字符串，列表等各种序列类型都适用。
>>>lang = "python"
>>>lang[-1]
'n'
>>>lang[-3]
'h'
>>>lst = ['python','java','c++']
lst[-2]
'java'
从右边开始编号，第-1号是右边第一个。
但是要切片的话，一定要遵循左边数字小于右边的数字。
例如：
lang = ;python'
lang[-3:-1]
'ho'
lst = ['python','java','c++']
lst[-3:-1]
['python','java']
在反向序列中的切片，同样遵循原则是：到包含开始位置，到结束位置之前。
反转
>>>ls = [1,2,3,4,5,6]
ls[::-1]  #反转
[6,5,4,3,2,1]
>>>ls
[1,2,3,4,5,6]  #ls的对象数据没有变化，只是用函数让元素反向排列了。
对字符串同样也可以
>>>lang = 'python'
lang[::-1]
'nohtyp'
>>>lang
'python'
上面的反转，不管是int类型还是lst类型反转之后，原来的值都没有改变。
在python中用函数将序列类型反转。
>>> ls = [1,2,3,4,5,6,7,8]
>>> ls
[1, 2, 3, 4, 5, 6, 7, 8]
>>> list(reversed(ls))
[8, 7, 6, 5, 4, 3, 2, 1]
用【list(reversed(object))】函数可以返回反转的序列.
它返回的对象也是可以迭代的，不过是已经将原来的序列对象反转了。
如下：
>>>list(reversed('abcd'))
['d','c','b','a']
关于列表的操作就暂时就这么多了。