3.2 Python列表类型及常用内置方法

1. List 列表

1.1 列表

特征: 使用中括号括起来, 内部可以存放多个数据, 元素与元素之间用逗号隔开, 元素可以是任意数据类型.

结构: 变量 = [元素1, 元素2, 元素3, ···]
1
2
3

# 空列表
list1 = []
print(list1)  # []
print(type(list1))  # 


list2 = [1, 1.1, 'a', [6, ]]
print(list2)  # [1, 1.1, 'a', [6]]

1
2
3
4
5
6
7
8
9

1.2 获取元素

列表中的每个元素都有对应的索引.

取值格式: 变量[索引]
嵌套取值: 变量[索引][索引]
1
2
3
4

list1 = [1, 1.1, ['a', 'b']]
print(list1[1])  # 1.1

# 第一步执行list1[2], 得到 ['a', 'b']. 第二步执行['a', 'b'][1], 得到'b'.
print(list1[2][1])  # b

1
2
3
4
5
6

1.3 修改元素

将指定的元素得值替换掉.
格式: 变量[索引] = 新值
1
2

list1 = [1, 2]
print(list1)  # [1, 2]

# 修改元素的值
list1[0] = 'a'
list1[1] = 'b'

print(list1)  # ['a', 'b']

1
2
3
4
5
6
7
8
9

2. 类型转换

能够支持for循环的数据, 都能够被list()转成列表.
底层就是进行了for循环取值, 取出来的值作为列表的元素.
1
2

list1 = ['tiger', 'monkey', 'cat']

print(list1, type(list1), )  # ['tiger', 'monkey', 'cat'] 

# 每个一个字符做为列表的一个元素
print(list('123456'))  # ['1', '2', '3', '4', '5', '6']

# 遍历字典只能拿到键, 以key最为列表的元素.
print(list({'a': 85, 'b': 75}))  # ['a', 'b']

# 集合是无序的, 遍历 去重之后的每个元素最为类别的元素
print(list({'a', 'b', 'c', 'a', }))  # ['a', 'b', 'c']

1
2
3
4
5
6
7
8
9
10
11
12
13

3. 索引取值与切片

索引取值: 取一个元素.
列表中每个元素占一个索引, 索引从0开始.

切片取值: 取多个元素.
取值格式: 字符串[start: stop: step]
start 起始值参数: 起始位置, 从第几位开始取值.
stop  上限值参数: 上限的位置, 只能获取到它的前一索引的值, 不包含它本身.
step  步长参数:   从左往右正向取值, 步长是负数从右往左反向取值(start 与 stop 参数对换).

省略索引:
省略第一个参数: 默认参数为0, 从索引0开始截取.
省略第二个参数: 默认惨为列表的长度, 意味着切片直至列表的末尾.
省略第三个参数: 默认为1, 从左往右正向取值. 
1
2
3
4
5
6
7
8
9
10
11
12
13

list1 = ['a', 'b', 'c', 'd', 'e']

# 索引取值
print(list1[0])  # a

# [起始值:终止值:步长]
print(list1[0:5])  # ['a', 'b', 'c', 'd', 'e']

# 第一个值为空默认从头开始
print(list1[:3])  # ['a', 'b', 'c']

# 第二个值为空默认到末尾
print(list1[0:])  # ['a', 'b', 'c', 'd', 'e']

# 步长
print(list1[0:5:2])  # ['a', 'c', 'e']

# 倒退写法
print(list1[-1:-6:-1])  # ['e', 'd', 'c', 'b', 'a']

# 倒退写法, 第一个 第二个 省略值互换.
print(list1[::-1])  # ['e', 'd', 'c', 'b', 'a']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4. 遍历列表

for 循环语句可以依次获取列表的元素.
1

list1 = [1, 2, 3, 4, 5, ]

# 变量列表的元素
for i in list1:
    print(i)

1
2
3
4
5
6

运行工具窗口显示:
1
2
3
4
5
1
2
3
4
5
6

5. 统计长度

Python 内置 len() 函数统计序列类型的元素个数.
1

list1 = ['A', 'B', 'B', 'B', 'A']
print(len(list1))  # 5

1
2
3

6. 列表类型存储数据

list1 = [0, 1, 2, ['0', '1', '2', , ]]
print(list1, id(list1)  # [0, 1, 2, ['0', '1', '2', '3']] 2885974982464

# 让列表的索引0指向 'a' 的内存地址
list1[0] = 'a'
print(list1, id(list1))  # ['a', 1, 2, ['0', '1', '2', '3']] 2885974982464

list1[3][0] = 'a'

print(list1, id(list1))  # ['a', 1, 2, ['a', '1', '2', '3']] 2885974982464

1
2
3
4
5
6
7
8
9
10
11

list1 = [1, 2, 3, [1, 2, 3], ]

"""
列表中的列表所有的元素都是同一个类型的值, 该列表会被认为是该类型列表.
当修改这个类型列表的值时, 期望是新值也是该类型, 新值类型不符时, Pycharm 会提示警告.
意外类型:(int, str)可能的类型:(SupportsIndex, int)(slice, Iterable[int])
这个警告是可以忽略的.
"""

list1[3][0] = 'a'
print(list1)  # [1, 2, 3, ['a', 2, 3]]

# 解决方案: 创建的列表没有类型
v: list = [None for i in range(3)]
v[0] = 1
v[1] = 2
v[2] = 3

list2 = [1, 2, 3, v]
list2[3][0] = 'a'

print(list2)  # [1, 2, 3, ['a', 2, 3]]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

7. 引用列表

列表引用另一个列表所指向的内存地址. 无论谁修改值, 它们的值都一样.
1

# 创建一个空列表, 赋值给l1
l1 = []
# l2 引用 l1的内存地址
l2 = l1

# 创建一个空列表, 赋值给l3
l3 = []

"""
Python 出于对性能的考虑, 但凡是不可变对象, 在同一个代码块中的对象, 只要是值相同的对象,
就不会重复创建, 而是直接引用已经存在的对象.
列表是可变类型, 没有上诉的优化.
"""

# l1 添加值
l1.append(1)

print(l1, l2, l3)

print(id(l1), id(l2), id(l3)) 
print(id(l1[0]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

运行工具窗口显示:
[1] [1] []
1176622328896 1176622328896 1176622235392
1176615479600
____________________________________________
l1 与 l2 使用同一个内存空间, 操作也都是一个空间.
1
2
3
4
5
6

8. 拼接与复制

Python 属于强类型语言, 不能类型的数据是无法互相操作的.
Python 中为了方便程序员的使用:
使用+号, 让列表与列表将加时, 表示拼接列表(末尾添加).
使用*号, 让列表与整型将乘时, 使其不再表示乘法, 而是复制n次元素.
1
2
3
4

8.1 列表的拼接

l1 = [1]
print(l1 + [2])  # [1, 2]

l1 += [2]
print(l1)  # [1, 2]


1
2
3
4
5
6
7

8.2 列表元素复制

l1 = [1]
print(l1 * 2)  # [1, 1]

l1 *= 2
print(l1)  # [1, 1]

1
2
3
4
5
6

9. 成员运算

in      判断某个个体是否在某个群体当中, 返回布尔值.
not in  判断某个个体是否不在某个群体当中, 返回布尔值.
1
2

l1 = [1, 2]

print(1 in l1)  # True

print(2 not in l1)  # False

1
2
3
4
5
6

10. 列表常用方法

* 列表使用方法, 会修改原值. 
1

10.1 追加元素

.append() 方法列表末尾追加元素.
1

list1 = [1, ]
print(list1)  # [1]

# 尾部追加
list1.append(2)
print(list1)  # [1, 2]

1
2
3
4
5
6
7

Pycharm 警告: 此列表创建可以作为列表文字重写 的解决方法.
1

list1 = [1, 2, 3, ]
list2 = [4, 5, 6, ]

# 列表合并
print(list1 + list2)  # [1, 2, 3, 4, 5, 6]

# 遍历列表元素通过append追加
for i in list2:
    list1.append(i)
print(list1)  # [1, 2, 3, 4, 5, 6]

1
2
3
4
5
6
7
8
9
10
11

10.2 插入元素

.insert(索引, 数据) 方法往列表中插入元素.
1

list1 = ['a', 'b', 'c', 'd', 'e']

# 在索引 0 插入0
list1.insert(0, 0)
print(list1)  # [0, 'a', 'b', 'c', 'd', 'e']

# 在索引 3 插入3
list1.insert(3, 3)
print(list1)  # [0, 'a', 'b', 3, 'c', 'd', 'e']

1
2
3
4
5
6
7
8
9
10

10.3 合并列表

.extend(列表) 拼接多个列表等价于 for + append.
1

list1 = ['a', 'b', 'c', 'd', 'e', ]
list2 = [1, 2, 3, 4, 5, ]

# 列表合并
list1.extend(list2)
print(list1)  # ['a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5]

1
2
3
4
5
6
7

10.4 删除数据

1.  del 关键字   使用 del 删除索引指向的值.
2. .remove(值)  将指定元素移除.
3. .pop(索引)   弹出(索引不写, 默认弹尾部), 弹出的值是 pop 方法的返回结果.
4. .clear()     清空列表.
1
2
3
4

1. del 关键字

list1 = ['a', 'b', 'c', 'd', 'e']

# del 删除索引指向的值
del list1[0:2]
print(list1)  # ['c', 'd', 'e']

1
2
3
4
5
6

2. remove 方法

list1 = ['a', 'b', 'c', 'd', 'e']

list1.remove('a')
print(list1)   # ['b', 'c', 'd', 'e']

1
2
3
4
5

3. pop 方法

list1 = ['a', 'b', 'c', 'd', 'e']

# 默认从尾部弹出
list1.pop()

print(list1)  # ['a', 'b', 'c', 'd']

# pop方法有返回值, 将返回值赋值给变量
tem = list1.pop()
print(tem)  # d

# 指定弹出索引1的值
list1.pop(1)
print(list1)  # ['a', 'c']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4. clear 方法

list1 = ['A', 'B', 'B', 'B', 'A']

# 清空列表
list1.clear()
print(list1)  # []

1
2
3
4
5
6

10.5 元素出现次数

.count() 方法统计某个元素在列表中出现的次数.
1

list1 = ['A', 'A', 'B', 'B', 'B', ]

print(list1.count('A'))  # 2
print(list1.count('B'))  # 3

1
2
3
4
5

10.6 获取值的索引

.index(值) 方法查询指定值的索引, 从左往右查找, 查到就返回.
不存在则报错: ValueError: xx is not in list. 值错误: xx不在列表中。.
1
2

list1 = [0, 1, 2, 3, 4, 5]

print(list1.index(0))  # 0
print(list1.index(1))  # 1

1
2
3
4
5

10.7 排序

.sort()    方法: 将列表的元素排按ASCII排序, 默认是升序.
.sort(reverse = True) 降序.
* 使用sort方法列表中元素必须是同一类型, 否则报错 TypeError:“x类型”和“x类型”的实例之间不支持 '<'.

.reverse() 方法: 将列表的元素倒序排列.
1
2
3
4
5

1. sort 方法

list1 = ['A', 'B', 'C', 'B', 'A', '1']

# 按ASCII排序-升序
list1.sort()
print(list1)  # ['1', 'A', 'A', 'B', 'B', 'C']

# 按ASCII排序-降序
list1.sort(reverse=True)  # 降序 ['C', 'B', 'B', 'A', 'A', '1']
print(list1)

1
2
3
4
5
6
7
8
9
10

2. reverse 方法

list1 = [1, 2, 3]

# 倒序排列
list1.reverse()
print(list1)  # [3, 2, 1]

1
2
3
4
5
6

11. 队列与堆栈

队列 (Queue): 亦称作先进先出 (First In First Out) 的线性表, 简称为FIFO表.
堆栈 (Stack): 亦称作后进先出 (Last In First Out)  的线性表, 简称为LIFO表.
1
2

num = 5
list1 = []
for i in range(num):
    list1.append(i)

# 先进先出
print('-----队列----')
for i in list1:
    print(i, end=' ')

# 后进先出
print('\n----堆栈----')
for i in range(num):
    print(list1.pop(), end=' ')


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行工具窗口显示:
-----队列----
0 1 2 3 4 
----堆栈----
4 3 2 1 0 
1
2
3
4
5

# 错误案例
list_0 = [0, 1, 2]  # 索引 0 -> 3
for i in list_0: 
    list_0.pop(i)
# 第一次弹出索引0后  list_0 = [1, 2] 
# 第二次弹出索引1后  list_0 = [1]  
# 第三次弹出索引2后  list_0 = [1]      没有索引2 报错
1
2
3
4
5
6
7

12. 练习

# 1.从列表l1 = ['kid', 'qq_xx', 'qxx']中剪切xx, 后赋值给新变量

l1 = ['kid', 'qq_xx', 'qxx']

l2 = []
for i in l1:
    l2.append(i.strip('xx'))
    
print(l2)
1
2
3
4
5
6
7
8
9

2.有列表['kid', 18,[2000, 1, 1]], 分别取出列表中的名字, 年龄, 出生的年, 月, 日赋值给不同的变量

3.用列表的insert与pop方法模拟队列

4.用列表的insert与pop方法模拟堆栈

5.列表l = ['a','b',1,'a','a'], 去重, 得到新列表,保存列表原来的顺序

1
2
3
4
5
6
7
8

---

文章的段落全是代码块包裹的, 留言0是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言1是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言2是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言3是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言4是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言5是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言6是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言7是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言8是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言9是为了避免文章提示质量低.

---