- 定义：
由一系列变量组成的可变序列容器。
特点：
列表是有序的可变元素的集合，使用中括号包围，元素之间用逗号分隔
列表是动态的，可以随时扩展和收缩
列表是异构的，可以同时存放不同类型的对象
列表中允许出现重复元素
语法：
(1) 创建列表：
两种方式创建列表
1）列表名 =
2）列表名 = list(可迭代对象）
示例代码：
1、通过构造函数创建
li1 = list() # 空列表
li1 = list(‘hogwarts’) # 字符串
li1 = list((1, 2, 3)) # 元组
li1 = list({4, 5, 6}) # 集合
li1 = list({‘a’: 7, ‘b’: 8}) # 字典
print(type(li1), li1)
(2) 添加元素：
列表名.append(元素)
列表.insert(索引，元素)
(3) 定位元素：
列表名[索引] = 元素
变量 = 列表名[索引]
变量 = 列表名[切片] 注意： 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 注意： 右侧必须是可迭代对象，左侧切片没有创建新列表。
(4) 遍历：
注意：列表的索引，默认正向索引，编号从 0 开始。支持反向索引，编号从-1 开始。
索引示意图
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
列表名[索引名]就是元素
(5) 删除元素：
列表名.remove(元素)
del 列表名[索引或切片]
(6) 列表使用
6.1 列表切片：
切片 [start: stop: step]
start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
stop 值: 指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值；
step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1。
三个值都是可选的，非必填
切片示意图：
切片示例：
切片基本用法
li = [‘h’, ‘o’, ‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’]
print(li[0:5:2]) # 打印[‘h’, ‘g’, ‘a’]
print(li[2:4]) # 省略了step，打印[‘g’, ‘w’]
print(li[:4]) # 省略了start和step，打印[‘h’, ‘o’, ‘g’, ‘w’]
print(li[2:]) # 省略了stop和step，打印[‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’]
print(li[::2]) # 省略start和stop，打印[‘h’, ‘g’, ‘a’, ‘t’]
print(li[::-1]) # 特殊的切片写法：逆序打印[‘s’, ‘t’, ‘r’, ‘a’, ‘w’, ‘g’, ‘o’, ‘h’]
6.2 列表运算符：
重复使用 * 运算符可以重复生成列表元素。
合并使用 + 加号运算符，可以将两个列表合二为一
示例：
1、重复
li = [1] * 5
print(li) # 打印[1, 1, 1, 1, 1]
2、合并
li1 = [1, 2, 3]
li2 = [99, 100]
print(li1 + li2) # 打印[1, 2, 3, 99, 100]
6.3 列表使用：成员检测
in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False。
not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False
示例代码：
li = [1, 2, 3]
in
print(1 in li) # 返回True
print(100 in li) # 返回False
not in
print(1 not in li) # 返回False
print(100 not in li) # 返回True
(7) 列表方法
7.1 extend()
extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾。
入参：可迭代对象 iterable
返回：None
示例代码：
extend()的用法
li =
li.extend(‘hogwarts’) # 添加的是字符串的所有字母
li.extend([1, 2, 3]) # 接收列表的所有元素
li.extend((4, 5, 6)) # 接收元组的所有元素
li.extend({‘a’: 1, ‘b’: 2}) # 接收字典的所有key值
print(li)
7.2 pop()
pop(index) 或 pop()
弹出并返回所指定索引的元素。
入参：索引值 index，可不传
返回：指定索引的元素
返回：未指定索引则返回末尾元素
如果索引值不正确，或者列表已经为空，则引发 IndexError 错误
示例代码：
letters = [‘h’, ‘o’, ‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’]
传入索引3，弹出元素 w
n1 = letters.pop(3)
print(n1) # 打印 w
不传参数，默认弹出末尾元素
n2 = letters.pop()
print(n2) # 打印 s
7.3 sort()
sort(key=None, reverse=False)
对列表进行原地排序，只使用 < 来进行各项间比较。
入参：支持 2 个关键字参数：
key：指定带有一个参数的函数，用于从每个列表元素中提取比较键。
reverse：默认值为 False 表示升序，为 True 表示降序
返回：None
示例代码
nums = [2, 4, 3, 1, 5]
1、不传参数，默认升序，数字从小到大排列
nums.sort()
print(nums) # 打印 [1, 2, 3, 4, 5]
2、指定key=len，按元素的长度排序
words = [‘Python’, ‘Java’, ‘R’, ‘Go’]
words.sort(key=len)
print(words) # 打印 [‘R’, ‘Go’, ‘Java’, ‘Python’]
3、指定reverse=True，降序
nums = [2, 4, 3, 1, 5]
nums.sort(reverse=True)
print(nums) # 打印 [5, 4, 3, 2, 1]
7.4 reverse()
reverse()：将列表中的元素顺序反转
参数：无
返回：None
反转只是针对索引值，元素之间不相互比较
示例代码
反转顺序
nums = [8, 1, 5, 2, 77]
nums.reverse()
print(nums) # 打印[77, 2, 5, 1, 8]
(8) 列表嵌套
嵌套列表是指在列表里存放列表
列表的常用方法都适用于嵌套列表
示例代码
1、创建嵌套列表
li_2d = [[‘a’, ‘b’, ‘c’], [1, 2, 3]]
print(type(li_2d)) # 打印<class ‘list’>
print(len(li_2d)) # 打印 2
2、访问嵌套列表中的元素
print(li_2d[0][2]) # 打印 ‘c’
(9) 列表推导式
- 列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版
- 语法：
[x for x in li if x ...]
示例代码：
“”"
实例：将 1-10 中的所有偶数平方后组成新的列表
“”"
1、传统解决方案
result =
for ele in range(1, 11):
if ele % 2 == 0:
result.append(ele ** 2)
print(result) # 打印 [4, 16, 36, 64, 100]
2、使用列表推导式
result = [ele ** 2 for ele in range(1, 11) if ele % 2 == 0]
print(result) # 打印 [4, 16, 36, 64, 100]