一网打尽_Python 列表及字典知识整理姊妹篇_列表(上篇)

一、引言

学习Python编程，列表和字典是两个特别重要的知识点，相对于元组、集合等其它数据类型，列表和字典在日常编程中使用的范围特别广，要想掌握好Python编程，尤其要深入裂解列表和字典的知识点，多加练习，并在日常编程中，要学会灵活运用，熟练掌握好这两个知识点，可应付大部分Python编程使用场景。

目前本人在学习Python编程，为更好地理解列表和字典的概念，特整理此文，方便自己也希望能帮助到和自己一样在学习Python道路上的朋友，也望对此知识熟悉的朋友们多多指正。

二、列表

列表(List)是Python内置的一种数据类型，也是Python最基本的数据结构。列表是有多个元素组成的有序序列，列表为其每个元素都分配了对应的数字(元素所在的位置)作为索引，可通过列表索引方便查询列表中的元素值。

列表中的元素不仅有序，而且列表中元素是可以重复的，所以列表[‘a’,’a’]是正确的，只是两个a所在的序列不同。

要特别注意的是列表的序列是从 0 或 -1 开始的。当从左至右查询列表的元素时，元素的查询序列是按照第一个元素(0)、第二个元素(1)、第三个元素(2)…这样查询的；当从右至左查询列表的元素时，元素的查询序列是按照第一个元素(-1)、第二个元素(-2)、第三个元素(-3)…这样查询的，所以要特别注意列表元素查询的方向及列表首个元素的序列值。

列表可以存放不同的数据类型，意即列表中的元素可以存放任何类型的数据，但在实际的使用中，一般不会将不同类型的元素存放在同一个列表中，通常是将不同类型的元素存放在对应的列表中，这样也更便于理解和管理。

对于列表，对其特性总结就是：有序、元素可重复、类型可不同。

说个题外话：很多人可能会好奇，列表的索引为何是从0开始，为此我也查询了相关一些资料，有两个原因，一是习惯，因为内存地址是从0开始，以0为基准数，偏移量就是地址，这样就简化了内存地址计算，编程语言的索引从 0 开始，最早要追溯到 BCPL 语言的设计；二是在表示列表范围和区间的时候，从0开始，这样可以更优雅的表达，同时也能更提高效率，a[:3]即取前3个元素, a[0] a[1] a[2]。

接下来就随我一起学习列表的相应知识。

2.1 声明列表

-- 声明一个空列表,使用[]符合即可声明一个列表
list01 = []

-- 声明一个有元素列表，列表会将所有元素存放在[]内
list02 = ['a','b']

注意事项

-- 虽然列表可以存放不同的元素，但采用如下方式声明列表就会报错
list03 = [0,a,1]
-- 执行print(list03)就会报如下错误
NameError: name 'a' is not defined
-- 原因是使用此方式声明列表，Python会将a定义为一个变量							
-- 如果采用 list04 = [0,'a',1]这样声明变量就没什么问题

重点知识

a, b = [1, 2] 
print(f'a的值:{a},a的类型{type(a)}; b的值:{b},b的类型{type(b)}')

-- 打印输出结果
a的值:1,a的类型<class 'int'>; b的值:2,b的类型<class 'int'>

****************************************************************
a, b, *c = [1, 2, 'A', 'B', 'C']
print(f'a的值:{a},a的类型{type(a)}; b的值:{b},b的类型{type(b)},c的值:{c},c的类型{type(c)}')

-- 打印输出结果
a的值:1,a的类型<class 'int'>; b的值:2,b的类型<class 'int'>,c的值:['A', 'B', 'C'],c的类型<class 'list'>
-- 采用此方式，a和b分别取值列表中的两个元素，*c取余下所有元素组成一个新列表

****************************************************************
a, b, c, d = [1, 'A', 'B', 2]
print(f'a的值:{a},a的类型{type(a)}; b的值:{b},b的类型{type(b)}, c的值:{c},c的类型{type(c)}, d的值:{d},d的类型{type(d)}')

-- 打印输出结果
a的值:1,a的类型<class 'int'>; b的值:A,b的类型<class 'str'>, c的值:B,c的类型<class 'str'>, d的值:2,d的类型<class 'int'>

2.2 索引取值

通过获取列表元素的索引值来获取列表信息。

# 定义一个列表，采用从左至右方式获取列表序列输出列表元素值
list01 = ['A','B','C','D']
print(list01[0])
print(list01[1])
print(list01[2])
print(list01[3])
# 打印输出结果如下
A
B
C
D
-- 但如果打印输出list01[4]就会报如下错误
    print(list01[4])
IndexError: list index out of range

# 也可以采用从右向左的方式打印列表序列获取元素值
list01 = ['A','B','C','D']
print(list01[-1])
print(list01[-2])
print(list01[-3])
print(list01[-4])

-- 打印输出结果
D
C
B
A

2.3 切片取值

使用切片获取列表的范围值，要特别注意的是使用list_name[初始索引:结束索引]进行切片左闭右开的区间范围，实际上所取的范围值是从初始索引到结束索引-1的范围区间值。

使用切片获取范围值时可以设置步长，步长就是截取的片段。

切片操作的基本表达式为：list_name[start_index : end_index : step]

• start_index：表示切片开始的索引位置，在执行切片时是包含该索引对应的元素值。
• end_index： 表示切片结束的索引位置，但要特别注意的是执行切片时是不包含该索引对应的元素值。
• step：表示切片步长值，步长可以为正也可以为负，当step为正时表示索引为正方向，step为负表示索引为负方向。

如未设置指定步长值，Python默认的切片步长值为1。

当start_index、end_index 、step都未写时，表示取的是整个列表。

当start_index、end_index 都未填写，step值为-1时，表示取的是整个序列的反向。

下面通过实验来详细描述列表如何通过设置步长值来获取列表范围值。

list01 = ['A','B','C']
print(list01[0:1]) # 获取从0开始到1-1的范围值
print(list01[0:2]) # 获取从0开始到2-1的范围值,意即list01[0]、list[1]
print(list01[0:3]) # 获取从0开始到3-1的范围值,意即list01[0]、list[1]、list[2]
print(list01[0:4]) # 获取从0开始到4-1的范围值,意即list01[0]、list[1]、list[2]、list[3]，但因为list[3]不存在，所以无法获取

-- 打印输出结果
['A']
['A', 'B']
['A', 'B', 'C']
['A', 'B', 'C']

*********************************************
list01 = ['A','B','C','D','E']
print("list01[2:5]取值: ",list01[2:5])  # 表示取值是从list01[2]至list01[4]
print("list01[-3:-1]取值: ",list01[-3:-1]) # 表示取值是从list01[-3]至list01[-2]，本质还是从列表左至右取
print("list01[:3]取值: ",list01[:3]) # 表示取值是从list01[0]至list01[2]
print("list01[1:]取值: ",list01[1:]) # 表示取值是从list01[1]至列表末尾
print("list01[:]取值: ",list01[:])  # 未设置步长值，表示取整个列表值
print("list01[2:4]取值: ",list01[2:4]) # 表示取值是从list01[2]至list01[3]
print("list01[-1:-3]取值: ",list01[-1:-3]) # 列表切片取值本质还是从列表左端到列表右端取值，所以该方式取值为空列表
print("list01[-1:-3:-1取值: ",list01[-1:-3:-1]) # 因为步长值为负值1，表示反向从列表倒数第一个到倒数第二个
print("list01[-1:-3:-2取值: ",list01[-1:-3:-2]) # 因为步长为负值2，表示反向从列表倒数第一个已步长2到倒数第二个
print("list01[::2]取值: ",list01[::2]) # 表示从列表起始索引位置到结束位置以步长值2做切片
print("list01[::-1]取值: ",list01[::-1]) # 表示对list01列表整个做反转

-- 打印输出结果
list01[2:5]取值:  ['C', 'D', 'E']
list01[-3:-1]取值:  ['C', 'D']
list01[:3]取值:  ['A', 'B', 'C']
list01[1:]取值:  ['B', 'C', 'D', 'E']
list01[:]取值:  ['A', 'B', 'C', 'D', 'E']
list01[2:4]取值:  ['C', 'D']
list01[-1:-3]取值:  []
list01[-1:-3:-1取值:  ['E', 'D']
list01[-1:-3:-2取值:  ['E']
list01[::2]取值:  ['A', 'C', 'E']
list01[::-1]取值:  ['E', 'D', 'C', 'B', 'A']

2.4 列表拼接

列表可以像字符串那样做列表间的拼接操作,但列表的拼接只能是多个列表间的操作，而不能使用列表和字符串或其它类型做拼接。

list01 = ['人生','苦短']
list02 = ['我','要','学','Python!']
list03 = list01 + list02
print(f"list03列表结果是：{list03}")

-- 打印输出结果
list03列表结果是：['人生', '苦短', '我', '要', '学', 'Python!']

# 列表不能和非列表类型进行拼接操作
list01 = ['A', 'B', 'C']
str = "Python"
print(list01 + str)

-- 打印输出结果
    print(list01 + str)
TypeError: can only concatenate list (not "str") to list
***************************
list01 = ['A', 'B', 'C']
dic_01 = {'k1': 'v1', 'k2': 'v2'}
print(list01 + dic_01)

-- 打印输出结果
    print(list01 + dic_01)
TypeError: can only concatenate list (not "dict") to list

2.5 列表乘法

列表还可以使用数字x乘以一个列表，即将原列表重复x次生成一个新列表,这一点和字符串操作相同。

如果初始列表是一个空列表，当使用数字去乘以这个列表时，得到的还是空列表。

list01 = ['A', 'B', 'C']
print(list01 * 3)

-- 打印输出结果
['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C']

-- 空列表乘以数字
list02 = []
print(list02) * 3

-- 打印输出结果
[]

2.6 列表嵌套

使用列表时，还可以在列表中再嵌套其它列表或字典等元素。

当列表中嵌套列表时，还可以通过索引层级取值来获取嵌套列表中的元素值。

list01 = ['A','B','C']
list02 = [1,2,3]
list03 = [list01,list02,{'k1':'v1','k2':'v2'}]
print(f"list03列表内容是：{list03}")

-- 打印输出结果
list03列表内容是：[['A', 'B', 'C'], [1, 2, 3], {'k1': 'v1', 'k2': 'v2'}]

-- 获取嵌套列表中的元素值
list01 = ['A', 'B', 'C', ['aa', 'bb'], [1, 2, 3], ]
# 获取嵌套列表 ['aa', 'bb']中的'aa'
print(list01[3][0])

-- 打印输出结果
aa

2.7 列表遍历

可以直接使用for循环语句可以遍历列表，同时也可以使用for循环结合列表长度及range()函数遍历、还可以使用iter()迭代器或enumerate()函数结合for循环遍历列表。

1) 第一种 直接使用for循环遍历列表

# 使用for循环遍历列表
list01 = [['A', 'B', 'C'], [1, 2, 3], {'k1': 'v1', 'k2': 'v2'}]
for i in list01:
	print(f"遍历后 i 取值是：{i}")
	
-- 打印输出结果   
遍历后 i 取值是：['A', 'B', 'C']
遍历后 i 取值是：[1, 2, 3]
遍历后 i 取值是：{'k1': 'v1', 'k2': 'v2'}

2) 第二种 使用for循环结合列表长度及range函数遍历列表

# 使用for循环结合列表长度及range函数遍历列表
list01 = [['A', 'B', 'C'], [1, 2, 3], {'k1': 'v1', 'k2': 'v2'}]
for i in range(len(list01)):
	print("列表遍历后的值是:",list01[i])
-- 打印输出结果   
列表遍历后的值是: ['A', 'B', 'C']
列表遍历后的值是: [1, 2, 3]
列表遍历后的值是: {'k1': 'v1', 'k2': 'v2'}

3) 第三种 使用for循环结合iter()迭代器遍历列表

# 使用for循环结合iter迭代器遍历历列表
list01 = [['A', 'B', 'C'], [1, 2, 3], {'k1': 'v1', 'k2': 'v2'}]
for i in iter(list01):
	print(f"列表遍历后的值是: {i}")
	
-- 打印输出结果
列表遍历后的值是: ['A', 'B', 'C']
列表遍历后的值是: [1, 2, 3]
列表遍历后的值是: {'k1': 'v1', 'k2': 'v2'}

4) 第三种 使用for循环结合enumerate()函数遍历列表

# 使用for循环结合enumerate()函数遍历列表
list01 = [['A', 'B', 'C'], [1, 2, 3], {'k1': 'v1', 'k2': 'v2'}]
for i in enumerate(list01):
	print(f"列表遍历后的值是: {i}")
	
-- 打印输出结果 
列表遍历后的值是: (0, ['A', 'B', 'C'])
列表遍历后的值是: (1, [1, 2, 3])
列表遍历后的值是: (2, {'k1': 'v1', 'k2': 'v2'})
# 使用enumerate()函数遍历列表，不仅输出遍历后的元素值，同时还输出了元素所对应的下标序列号。

2.8 列表删除数据

可以使用del命令来删除列表中元素，并可以删除嵌套列表中的元素。使用del 删除列表中的元素时，要传入的是列表中元素的所在序列值，使用del list_name[:]这种不填写初始序列和结束序列的切片可以清空一个列表。

list01 = ['A', 'B', 'C', ['aa', 'bb'], [1, 2, 3], ]
del list01[0]
print("删除list01[0]后当前列表值：",list01)
del list01[-1]
print("删除list01[-1]后当前列表值：",list01)
del list01[2][0]
print("删除list01[2][0]后当前列表值：",list01)

-- 打印输出结果
删除list01[0]后当前列表值： ['B', 'C', ['aa', 'bb'], [1, 2, 3]]
删除list01[-1]后当前列表值： ['B', 'C', ['aa', 'bb']]
删除list01[2][0]后当前列表值： ['B', 'C', ['bb']]

******************************************************
-- 若删除的列表为空，或者删除的元素所对应的索引值超出了列表长度范围都是会报错
list01 = ['A']
del list01[2]

-- 打印输出结果
    del list01[2]
IndexError: list assignment index out of range

******************************************************
# 定义一个列表list01
list01 = ['A','B']
del list01[:]
print(f"当前列表list01内容为: {list01}")

-- 打印输出结果
当前列表list01内容为: []

2.9 列表内置方法

Python中有多个基于列表操作的内置方法，其中在日常编程中使用较频繁的是如下一些内置方法，然后我们基于这些内置方法来详细讲解其用法。

方法	作用
append()	向列表追加元素
insert()	向列表任意位置添加元素
extend()	向列表合并一个列表
pop()	根据索引删除列表元素（为空删除最后一个元素）
remove()	根据元素值删除列表元素
clear()	清空列表元素
sort()	排序（升序）
reverse()	翻转列表
count()	元素重复的次数
index()	查找元素对应索引

2.9.1 append()方法

列表中append()方法语法格式为：list.append(obj)，obj是添加到原列表末尾的对象，记住，使用append()方法是将新对象添加到原列表的末尾生成新列表，append()方法没有返回值，并且原列表和新列表内存地址相同。

list01 = ['A','B']
print(f"list01列表添加新对象前内存地址：{id(list01)}")
print(list01.append('a'))   # 执行append()方法没有返回值
list01.append('a')
print(f"当前列表list01内容为：{list01}")
print(f"list01列表添加新对象后内存地址：{id(list01)}")

-- 打印输出结果
list01列表添加新对象前内存地址：34067656
None
当前列表list01内容为：['A', 'B', 'a', 'a']
list01列表添加新对象后内存地址：34067656

2.9.2 insert()方法

列表中insert()方法用来将新对象添加到列表中的指定位置，语法格式为：list.insert(index, obj)，index是新对象将要插入的列表索引位置，obj是表示将要插入的新对象，该方法同样无返回值，并且原列表和新列表内存地址相同。

list01 = ['A','B','C']
print(f"list01列表添加新对象前内存地址：{id(list01)}")
print(list01.insert(0,'a'))
print(f"当前列表list01内容为：{list01}")
list01.insert(2,'b')
print(f"当前列表list01内容为：{list01}")
print(f"list01列表添加新对象后内存地址：{id(list01)}")

-- 打印输出结果
list01列表添加新对象前内存地址：22856872
None
当前列表list01内容为：['a', 'A', 'B', 'C']
当前列表list01内容为：['a', 'A', 'b', 'B', 'C']
list01列表添加新对象后内存地址：22856872

2.9.3 extend()方法

列表中extend()方法用来在原列表的末尾一次性追加其它序列(可以是列表、元组、集合、字典、字符串等)中的多个值，扩展原列表生成新列表。extend()方法语法格式为：list.extendextend(seq)，seq是元素列表，可以是多种类型。

注意，若扩展的对象是集合，会将集合中的key作为元素添加到原列表中，若扩展对象是字符串，会将字符串进行拆分，并将拆分后的字符串元素扩展至列表中。

extend()方法同样没有返回值，并且原列表和新列表内存地址相同。

1）extend()方法扩展一个列表

-- extend()方法扩展一个列表
# 定义两个列表list01和list02
list01 = ['A',1,'B']
list02 = ['a','b']
print(f"list01扩展列表前内存地址：：{id(list01)}")
# 使用extend方法扩展一个列表
list01.extend(list02)
print(f"当前list01的内容为：{list01}")
print(f"list01扩展列表后内存地址：：{id(list01)}")

-- 打印输出结果
list01扩展列表前内存地址：：26465480
当前list01的内容为：['A', 1, 'B', 'a', 'b']
list01扩展列表后内存地址：：26465480

2）extend()方法扩展一个元组

-- extend()方法扩展一个元组
# 定义列表list01
list01 = ['A',1,'B']
# 定义一个元组tup_01
tup_01 = ('Very','Good!')
print(f"list01扩展元组前内存地址：：{id(list01)}")
# 使用extend方法扩展一个元组
list01.extend(tup_01)
print(f"当前list01的内容为：{list01}")
print(f"list01扩展后内存地址：：{id(list01)}")

-- 打印输出结果
list01扩展元组前内存地址：：26858696
当前list01的内容为：['A', 1, 'B', 'Very', 'Good!']
list01扩展元组后内存地址：：26858696

3）extend()方法扩展一个集合

-- extend()方法扩展一个集合
# 定义列表 list01
list01 = ['A',1,'B']
# 定义一个集合 set_01
set_01 = {'B','Oracle', 'MySQL'}
print(f"list01扩展集合前内存地址：：{id(list01)}")
# 使用extend方法扩展一个集合
list01.extend(set_01)
print(f"当前list01的内容为：{list01}")
print(f"list01扩展集合后内存地址：：{id(list01)}")

-- 打印输出结果
list01扩展集合前内存地址：：30397608
当前list01的内容为：['A', 1, 'B', 'MySQL', 'Oracle', 'B'] # 因为集合是无序的，所以集合中的B插入列表位置不定
list01扩展集合后内存地址：：30397608

4）extend()方法扩展一个字典

-- extend()方法扩展一个字典
# 定义列表 list01
list01 = ['A',1,'B']
# 定义一个字典 dic_01
dic_01 = {'Name':'shanglei','Age':18,'Gender':'male'}
print(f"list01扩展字典前内存地址：：{id(list01)}")
# 使用extend方法扩展一个字典
list01.extend(dic_01)
print(f"当前list01的内容为：{list01}")
print(f"list01扩展字典后内存地址：：{id(list01)}")

-- 打印输出结果
list01扩展字典前内存地址：：23516360
当前list01的内容为：['A', 1, 'B', 'Name', 'Age', 'Gender'] # extend()方法会只添加字典中的key
list01扩展字典后内存地址：：23516360

5）extend()方法扩展一个字符串

-- extend()方法扩展一个字符串
# 定义列表 list01
list01 = ['A',1,'B']
# 定义一个字符串 str_01
str_01 = 'Python'
print(f"list01扩展字符串前内存地址：：{id(list01)}")
# 使用extend方法扩展一个字符串
list01.extend(str_01)
print(f"当前list01的内容为：{list01}")
print(f"list01扩展字符串后内存地址：：{id(list01)}")

-- 打印输出结果
list01扩展字符串前内存地址：：11125928
当前list01的内容为：['A', 1, 'B', 'P', 'y', 't', 'h', 'o', 'n']
list01扩展字符串后内存地址：：11125928

2.9.4 pop()方法

列表中pop()方法用于剔除列中的一个元素(默认是列表中最后一个元素)。其语法格式为：list.pop([index=-1])，index=-1默认是列表中最后一个元素索引值，通常可不写，若要剔除列表中的其它元素，要写该元素所在的索引值，注意，该索引值不能超出列表总长度。

pop()方法执行后有返回值，会返回被剔除的元素值。执行pop()方法后原列表和新列表内存地址相同。

list01 = ['A',1,'B','C','D']
print(list01.pop(-1))
print(f"当前list01的内容为：{list01}")
print(list01.pop())
print(f"当前list01的内容为：{list01}")
print(list01.pop(5))

-- 打印输出结果
D
当前list01的内容为：['A', 1, 'B', 'C']
C
当前list01的内容为：['A', 1, 'B']
    print(list01.pop(5))           # 因为index(5)超出了列表的总长度，所以执行报错
IndexError: pop index out of range

2.9.5 remove()方法

列表中remove()方法是剔除列表中一个元素，当列表中有多个重复的元素时，remove()方法默认剔除的是第一个匹配元素。

remove方法语法格式为：list.remove(obj)，obj是表示列表中被剔除的第一个匹配元素对象。

注意，不同于pop()方法，remove()方法所传递的是列表元素名称而不是元素所在的序列值。

remove()方法没有返回值，执行remove()方法后原列表和新列表内存地址相同。

# 定义一个列表list01
list01 = ['A','A','a','b','A',1,2]
print(list01.remove(-1))   # 对比下pop()方法接收的对象

-- 打印输出结果
# 因为该remove()方法接收到的是列表元素序列值，所以会报错
    print(list01.remove(-1))
ValueError: list.remove(x): x not in list

*****************************************************
# 定义一个列表list01
list01 = ['A','A','a','b','A',1,2]
print(f"list01当前内存地址：：{id(list01)}")
print(list01.remove(2))      # 无返回值
print(f"当前list01的内容为：{list01}")
list01.remove('A')
print(f"剔除第一个A后当前list01的内容为：{list01}")
print(f"list01剔除元素后内存地址：：{id(list01)}")

-- 打印输出结果
list01当前内存地址：：11064520
None
当前list01的内容为：['A', 'A', 'a', 'b', 'A', 1]
剔除第一个A后当前list01的内容为：['A', 'a', 'b', 'A', 1]
list01剔除元素后内存地址：：11064520

****************************************************
-- 若被剔除的是一个不存在的对象，则执行remove()会报错
# 定义一个列表list01
list01 = ['A','A','a','b','A',1,2]
print(list01.pop('Oracle'))

-- 打印输出结果
    print(list01.pop('Oracle'))
TypeError: 'str' object cannot be interpreted as an integer

2.9.6 clear()方法

列表中clear()方法用于清空列表，和del list[:]用法相同。语法格式为 list.clear()，无需传递参数值，clear()方法也无返回值。

# 定义一个列表list01
list01 = ['Python','Oracle','MySQL']
# 执行clear()方法并查看是否有返回值
print(list01.clear())
print(f'list01被清空后内容为：{list01}')

-- 打印输出结果
None
list01被清空后内容为：[]

2.9.7 sort()方法

列表中sort()方法用于对原列表进行排序，按升序或倒序进行排序，sort()方法要求列表中的元素对象相同。语法格式为：list_name.sort(reverse=…, key=… )。

sort()方法接受两个可选参数，reverse是该方法第一个可选参数，reverse用来传递一个布尔值(True或False)，默认值是False，表示列表中元素按升序进行排序。如设置该值为True，表示列表中元素会按降序进行排序。

key是sort()方法第二个可选参数，它需要一个函数或方法，用于指定可能有的任何详细排序标准。

sort()方法无返回值，因为该方法只是对原列表中的元素进行排序，并不会修改列表中的值，所以无返回值。

以下通过实验来进行详细说明。

1）对数字列表进行排序

# 定义一个含有数字的列表 list_num
list_num = [1,-2,0,3,4,7,-11]
# 采用默认方式排序，此时reverse默认为False
list_num.sort()
print(f"对list_num默认排序后内容为：{list_num}")
# 设置reverse=True进行倒序排序
list_num.sort(reverse=True)
print(f"对list_num设置reverse=True排序后内容为：{list_num}")

-- 打印输出结果
对list_num默认排序后内容为：[-11, -2, 0, 1, 3, 4, 7]
对list_num设置reverse=True排序后内容为：[7, 4, 3, 1, 0, -2, -11]

2）对字符串列表进行排序

当对字符串列表进行默认排序时，是按照大写字母在前，小写字母在后；当排序的内容含有数字类型字符串时，会首先将数字字符串排在前，非数字字符串按照大小写排在后。

# 定义一个含有数字的列表 list_str
list_str = ['c','Python','Oracle','MySQL','a','A','B','b','c']
list_str.sort()
print(f"对list_num默认排序后内容为：{list_str}")
list_str.sort(reverse=True)
print(f"对list_num设置reverse=True排序后内容为：{list_str}")
print()
# 定义一个含有数字字符串和普通字符串的列表 list_str_num
list_str_num = ['0','-1','c','Python','Oracle','1','3','2','a','A','B','b','c']
list_str_num.sort()
print(f"对list_num默认排序后内容为：{list_str_num}")
list_str_num.sort(reverse=True)
print(f"对list_num设置reverse=True排序后内容为：{list_str_num}")

-- 打印输出结果
对list_num默认排序后内容为：['A', 'B', 'MySQL', 'Oracle', 'Python', 'a', 'b', 'c', 'c']
对list_num设置reverse=True排序后内容为：['c', 'c', 'b', 'a', 'Python', 'Oracle', 'MySQL', 'B', 'A']

对list_num默认排序后内容为：['-1', '0', '1', '2', '3', 'A', 'B', 'Oracle', 'Python', 'a', 'b', 'c', 'c']
对list_num设置reverse=True排序后内容为：['c', 'c', 'b', 'a', 'Python', 'Oracle', 'B', 'A', '3', '2', '1', '0', '-1']

3）对列表设置key参数进行排序

-- 对列表按照key=len传值进行排序
# 定义一个字符串列表 list_str
list_str = ["Python", "Oracle","Java", "C++", "Go", "openGauss"]
list_str.sort(key = len)    # 将内置len函数分配给key,会按照列表中元素的长度进行排序
print(f"对list_str列表按照key=len排序后内容为：{list_str}")
list_str.sort(reverse=True,key = len)
print(f"对list_str列表按照key=len并设置倒序排序后内容为：{list_str}")

-- 打印输出结果
对list_str列表按照key=len排序后内容为：['Go', 'C++', 'Java', 'Python', 'Oracle', 'openGauss']
对list_str列表按照key=len并设置倒序排序后内容为：['openGauss', 'Python', 'Oracle', 'Java', 'C++', 'Go']

-- 对key传值按照指定元素进行排序
# 定义一个函数SortBySecond，并取列表的第二个元素
def SortBySecond(obj):
	return obj[1]
# 定义一个含有元组的列表 list_num
list_num = [(1, 1), (3, 4), (5, 2), (1, 3),(3,-1)]
# 指定按照第二个元素排序
list_num.sort(key=SortBySecond)
# 输出类别
print (f'排序后信息内容：{list_num}')
print()
list_num.sort(reverse=True,key=SortBySecond)
# 输出类别
print (f'倒序排序后信息内容：{list_num}')

-- 打印输出结果
排序后信息内容：[(3, -1), (1, 1), (5, 2), (1, 3), (3, 4)]

倒序排序后信息内容：[(3, 4), (1, 3), (5, 2), (1, 1), (3, -1)]

2.9.8 reverse()方法

我们在上面的sort()方法中已经接触了些reverse()方法的用法，reverse() 方法主要用于反向列表中的元素。语法格式为：list.reverse()，reverse() 方法也没有返回值，因为其未改变列表中的元素值，所以其没有返回值。

# 定义一个列表 list01
list01 = ['Python','C++','Oracle']
list01.reverse()
print(f"list01反转后内容为：{list01}")

-- 打印输出结果
list01反转后内容为：['Oracle', 'C++', 'Python']

2.9.9 count()方法

列表中count() 方法用于统计某个元素在列表中出现的次数。其语法格式为：list.count(obj)，obj表示用于统计的元素对象。count()有返回值，返回值是统计元素对象在列表中出现的次数。

# 定义一个列表 list01
list01 = ['Python', 'C++', 'Oracle', 'Oracle']
print("Oracle元素在列表中出现的次数为：", list01.count('Oracle'))

-- 打印输出结果
Oracle元素在列表中出现的次数为： 2

2.9.10 index()方法

列表中index() 函数用于从列表中查找出某个值第一个匹配项的索引位置。语法格式为：list.index(x[, start[, end]])，x代表查找的元素对象，start和end都是可选选项，主要用于在列表切片范围内查找指定元素第一次匹配到的索引位置，如果start和end不设置，默认是查找整个列表。

index()方法有返回值，其返回值用来显示匹配对象的索引位置，如果未能从列表中匹配到指定的对象，其会抛出异常。

# 定义一个列表 list01
list01 = ['A','B','a','AA','a']
print('a的索引值为：',list01.index('a')) # 会匹配列表中第一个'a'所在的索引位置
print('c的索引值为：',list01.index('c')) # 因为'c'在列表中不存在，执行会报错

-- 打印输出结果
a的索引值为： 2
    print('c的索引值为：',list01.index('c'))
ValueError: 'c' is not in list

-- 根据切片范围查找元素所在索引位置
# 定义一个列表 list01
list01 = ['A','B','a','AA','a']
print('a的索引值为：',list01.index('a',1,-1))
print('a的索引值为：',list01.index('a',1,-3))  # 超出范围会报错

-- 打印输出结果
a的索引值为： 2
    print('a的索引值为：',list01.index('a',1,-3))
ValueError: 'a' is not in list

2.10 列表推导式

Python推导式(comprehensions)，亦称解析式，是Python的一种独有特性。使用推导式可以从一个数据序列构建成另一个新的数据序列的结构体，

Python支持四种数据类型的推导式，Python2和Python3均支持，这四种推导式分别是：

• 列表(list)推导式
• 字典(dict)推导式
• 集合(set)推导式
• 元组(tuple)推导式

列表推导式的基本格式为：[表达式 for 变量 in 列表] 或 [表达式 for 变量 in 列表 if 条件]

-- 过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母
# 定义一个列表 ListBook
ListBooks = ['Java', 'Python', 'C++', '.Net', 'Ruby', 'Php']
NewListBooks = [book.upper() for book in ListBooks if len(book) > 3]
print(NewListBooks)

-- 打印输出结果
['JAVA', 'PYTHON', '.NET', 'RUBY']

**********************************************************
-- 求(x,y),其中x是0-5之间的偶数，y是0-5之间的奇数组成的列表
list = [(x, y) for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 == 1]
print(list)

-- 打印输出结果
[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]

三、列表练习题

3.1 题目一

-- 求M中3, 6, 9组成的列表
M = [[1,2,3], [4,5,6], [7,8,9]] 

3.2 题目二

-- 生成间隔5分钟的时间列表序列

3.3 题目三

-- 通过input引导用户输入一种编程语言，判断该语言是否存在语言列表中
prog_lang = ["Python","C++",".Net","Java"]

3.4 题目四

-- 求M,N中矩阵和元素的乘积
M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
N = [[2, 2, 2], [3, 3, 3], [4, 4, 4]]