列表的索引和切片
 
列表是序列类型中的可变类型，它的索引和切片操作，和通用的序列操作比较，有许多不一样的地方，主要体现在利用索引和切片对列表元素进行增、删、改。
 
索引和切片是序列类型通用操作，详细的规则和用法，见序列索引和切片。
 
列表可以利用索引替换某一个元素：
 
_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. 列表索引(查询)
2. 列表切片（取出原列表的子列表，生成一个新的列表）
3. 列表元素顺序反向
4. 替换列表某段子列表
5. 在列表开头插入元素
   
  
 

 
列表索引与切片
 
1. 列表索引(查询)
 
# 正索引
list=[1,2,3,4,5]
print("第二个元素是："+str(list[1]))
 
第二个元素是：2
 
# 负索引
list=[1,2,3,4,5]
print("倒数第二个元素是："+str(list[-2]))
 
倒数第二个元素是：4
 
2. 列表切片（取出原列表的子列表，生成一个新的列表）
 
list=[1,2,3,4,5]
print("无间距取出列表："+str(list[1:4]))
print("有间距取子列表："+str(list[0:5:2]))
print("取出最后两个元素："+str(list[-2:]))
 
无间距取出列表：[2, 3, 4]
有间距取子列表：[1, 3, 5]
取出最后两个元素：[4, 5]
 
3. 列表元素顺序反向
 
list=[1,2,3,4,5]
print("列表元素顺序反向："+str(list[-1::-1]))
 
列表元素顺序反向：[5, 4, 3, 2, 1]

 
4. 替换列表某段子列表
 
list=[1,2,3,4,5]
list[0:2]=[9,8]
print(list)
 
[9, 8, 3, 4, 5]
 
5. 在列表开头插入元素
 
list=[1,2,3,4,5]
list[:0]=[7,6]
print(list)
 
[7, 6, 1, 2, 3, 4, 5]

列表的索引和切片
 
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']]

列表的索引与切片
 
列表的索引与字符串的索引类似，都分为正向与反向索引，如图所示。
 
 在图中，列表中每一个元素都对应两个下标，例如索引列表中元素5，可以通过以下两种方式指定：
 
 列表的切片与字符串的切片也类似，列表的切片可以从列表中取得多个元素并组成一个新列表。
 
接下来演示列表的切片，如例所示。