4.2 Python 列表类型常用操作及内置方法

1. List列表

1.1 列表

特征: 使用中括号括起来, 内部可以存放多个数据, 元素与元素之间用逗号隔开, 
元素可以是任意数据类型, 元素个数无限制.
列表中的每个元素都被分配一个数字作为索引, 用来表示该元素在列表内所排在的位置, 索引从0开始.

结构: 变量 = [元素1, 元素2, 元素3, ···]
多维列表: 当列表的元素是一个容器类型时, 那么这个列表被称为多维列表, 嵌套几层就是几维列表.

# 空列表
list1 = []
print(list1)  # []
print(type(list1))  # <class 'list'>

# 多维列表
list2 = [1, 1.1, 'a', [6, ]]
print(list2)  # [1, 1.1, 'a', [6]]

1.2 获取元素

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

取值格式: 变量[索引]
多维列表取值: 
变量[索引][索引]...

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.3 修改元素

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

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

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

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

2. 类型转换

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

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

print(list1, type(list1), )  # ['tiger', 'monkey', 'cat'] <class 'list'>

# 每个一个字符做为列表的一个元素
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']

3. 索引取值与切片

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

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

省略索引:
省略第一个参数: 默认参数为0, 从索引0开始截取.
省略第二个参数: 默认惨为列表的长度, 意味着切片直至列表的末尾.
省略第三个参数: 默认为1, 从左往右正向取值. 

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']

4. 遍历列表

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

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

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

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

5. 统计长度

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

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

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

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]]

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

# 设置列表的预期类型 为 任意类型列表, 也可以做设置为 list1: list, 表达的意思一样.
list1: list[any]
list1[3][0] = 'a'
print(list1)  # [1, 2, 3, ['a', 2, 3]]

补充知识:
list[int] 整型列表: 表示列表的所有元素为整型.
list[str] 字符列表: 表示列表的所有元素为字符串.
...
list[any] 字符列表: 表示列表的元素可以是任意类型.

7. 引用列表

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

# 创建一个空列表, 赋值给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] [1] []
1176622328896 1176622328896 1176622235392
1176615479600
____________________________________________
l1 与 l2 使用同一个内存空间, 操作也都是一个空间.

a = [1, 2, 3]  # 申请一个内存空间把值[1, 2, 3]放进去绑定给变量名a.
b = a  # 将a的内存空间地址给b引用, a, b同时指向内存地址.
a = 200  # 申请一个内存空间把值200放进去绑定给变量名a, 原来的绑定断开. (重新赋值)
print(b)  # b 不受影响.

k = [1, 2, 3]  # 申请一个内存空间把值[1, 2, 3]放进去绑定给变量名k.
v = k  # 将k的内存空间地址给v引用k v同时指向内存地址.
k.append(200)  # 在内存空间将值200添加进去. (操作同一个列表空间.)
print(v)  # v 也更随着变量

8. 拼接与复制

符号	作用	示例
+ 加号	拼接列表.	[1] + [2] = [1, 2]
* 乘号	复制列表元素.	[1] * 2 = [1, 1]

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

8.1 列表的拼接

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

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

8.2 列表元素复制

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

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

9. 成员运算

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

l1 = [1, 2]

print(1 in l1)  # True

print(2 not in l1)  # False

10. 列表常用方法

* 列表属于可变类型, 可变类型的部分方法会修改原值.

列表方法效率问题: 
列表的某些增加元素和删除元素方法会涉及到元素的大量移动, 这会影响列表操作的效率.
非必要情况下, 一般只在列表的尾部添加元素或删除元素.

10.1 追加元素

.append()方法: 列表末尾追加元素.
在列表的序列对象末尾添加一块空间, 在这个空间内追加值, 操作效率高.

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

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

Pycharm警告: 此列表创建可以作为列表文字重写, 以上就是上面定义的变量没有使用, 就使用append.
解决方法: 直接将append添加的元素卸载第一行赋值语句中.

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]

10.2 插入元素

.insert(索引, 数据)方法: 往列表中插入元素.
它插入位置的值和后面所有的值都需要后移, 涉及大量的元素复制, 影响列表的操作效率.

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']

10.3 合并列表

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

.extend()方法的效率比'+'号拼接效率高.
list1 + list2会创建一个新的列表, 新列表会所有的列表元素进行复制, 多少个元素就需要复制多少次.
extend方法在原有list列表末尾追加另一个列表的元素, 工程少一半.

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

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

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

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

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


# 对类别类型进行注解, 可以是 list2: list 意思差不多.
list2: list[any]
# 列表合并
list3 = list1 + list2
print(list3, id(list3))  # ['a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5] 3164889277760

10.4 删除数据

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

删除的值不是末尾的值, 那么所有的值需要向前填充, 涉及大量的元素复制, 影响列表操作效率.

1. del 关键字

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

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

2. remove 方法

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

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

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']

4. clear 方法

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

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

10.5 元素出现次数

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

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

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

10.6 获取值的索引

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

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

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

10.7 排序

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

.reverse()方法: 将列表的元素倒序排列.

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)

2. reverse 方法

list1 = [1, 2, 3]

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

11. 队列与堆栈

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

# 使用列表模拟队列和堆栈.
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=' ')

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

# 错误案例
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 报错

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)

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

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

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

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