软件测试/测试开发丨Python常用数据结构学习笔记

Python常用数据结构

list 列表

列表定义

列表是有序的可变元素的集合，使用中括号[]包围，元素之间用逗号分隔
列表是动态的，可以随时扩展和收缩
列表是异构的，可以同时存放不同类型的对象
列表中允许出现重复元素

列表使用：创建

创建列表
- 通过构造函数创建 li = list()
- 中括号创建并填充 li = [1,2,3]
- 列表推导式li = [x for x in range(10)]

列表使用：索引

索引
- 默认正向索引，编号从 0 开始。
- 支持反向索引，编号从-1 开始。

列表使用：切片

切片 [start: stop: step]
- start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
- stop 值: 指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值；
- step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1。
- 三个值都是可选的，非必填

列表使用：运算符

重复
- 使用 * 运算符可以重复生成列表元素。
合并
- 使用 + 加号运算符，可以将两个列表合二为一。

列表使用：成员检测

in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False。
not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False。

列表方法 append()

append(item)：将一个对象 item 添加到列表的末尾。
入参：对象 item
返回：None

列表方法 extend()

extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾。
入参：可迭代对象 iterable
返回：None

列表方法 insert()

insert(index, item)：将一个对象插入到指定的索引位置
入参：索引值 index ，一个对象 item
返回：None
原索引位置及后面的元素后移一位

列表方法 pop()

pop(index) 或 pop()
弹出并返回所指定索引的元素。
入参：索引值 index，可不传
返回：指定索引的元素
返回：未指定索引则返回末尾元素
如果索引值不正确，或者列表已经为空，则引发 IndexError 错误

列表方法 remove()

remove(item)
移除列表中第一个等于 item 的元素
入参：指定元素 item
返回：None
目标元素必须已存在，否则会报 ValueError

列表方法 sort()

sort(key=None, reverse=False)
对列表进行原地排序，只使用 < 来进行各项间比较。
入参：支持 2 个关键字参数：
- key：指定带有一个参数的函数，用于从每个列表元素中提取比较键。
- reverse：默认值为 False 表示升序，为 True 表示降序
返回：None

列表方法 reverse()

reverse()：将列表中的元素顺序反转
参数：无
返回：None
反转只是针对索引值，元素之间不相互比较。

列表嵌套

嵌套列表是指在列表里存放列表
列表的常用方法都适用于嵌套列表

列表推导式

列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版
语法：[x for x in li if x ...]

Tuple 元组

元组定义

元组是有序的不可变对象集合
元组使用小括号包围，各个对象之间使用逗号分隔
元组是异构的，可以包含多种数据类型

元组使用：创建

创建
- 使用逗号分隔 tp = 1,2,3
- 通过小括号填充元素tp = (1,2,3)
- 通过构造方法 tuple(iterable)

元组使用：索引

索引
可以通过索引值来访问对应的元素。
- 正向索引，默认编号从 0 开始
- 反向索引，默认编号从-1 开始

元组使用：切片

切片 [start: stop: step]
- 三个值都是可选的，非必填
- start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
- stop 值：指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取元组允许的最大索引值；
- step 值：步长值指示每一步大小，如果没有指定，则默认步长值为 1。

元组常用方法 index()

index(item)
返回与目标元素相匹配的首个元素的索引。
目标必须在元组中存在的，否则会报错

元组常用方法 count()

count(item)：返回某个元素出现的次数。
入参：对象 item
返回：次数

元组解包

元组解包：把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中。

# 传统逐个赋值的方式
t = (1, 2, 3)
a = t[0]
b = t[1]
c = t[2]
print(a, b, c)

# 使用元组解包，一气呵成
a, b, c = (1, 2, 3)
print(a, b, c)

元组与列表

相同点
- 都是有序的
- 都是异构的，能够包含不同类型的对象
- 都支持索引和切片
区别
- 声明方式不同，元组使用()，列表使用 []
- 列表是可变的，元组是不可变的

Set 集合

集合定义

无序的唯一对象集合
用大括号{}包围，对象相互之间使用逗号分隔
集合是动态的，可以随时添加或删除元素
集合是异构的，可以包含不同类型的数据

集合使用：创建

创建
- 通过使用{}填充元素
- 通过构造方法 set()
- 通过集合推导式

"""创建集合"""
# 1、使用大括号{}填充元素
st4 = {1, 2, 3}
st5 = {'a', 'b', 'c'}

# 2、使用构造方法创建集合
st1 = set()  # 空集合
st2 = set('hogwarts')

li = [1, 1, 2, 2, 3, 3]
st3 = set(li)


# 3、使用集合推导式
st6 = {x for x in li}

# 注意：不要单独使用{ }来创建空集合
st7 = {}  # 这是字典类型
print(type(st7))

集合使用：成员检测

in
- 判断元素是否在集合中存在
not in
- 判断元素是否在集合中不存在

集合方法 add()

add(item)：将单个对象添加到集合中
入参：对象 item
返回：None

集合方法 update()

update(iterable)
批量添加来自可迭代对象中的所有元素
入参：可迭代对象 iterable
返回：None

集合方法 remove()

remove(item)：从集合中移除指定元素 item。
入参：指定元素值
返回：None
如果 item 不存在于集合中则会引发 KeyError

集合方法 discard()

discard(item)：从集合中移除指定对象 item。
入参：指定对象值
返回：None
元素 item 不存在没影响，不会抛出 KeyError 错误。

集合方法 pop()

pop()：随机从集合中移除并返回一个元素。
入参：无。
返回：被移除的元组。
如果集合为空则会引发 KeyError。

集合方法 clear()

clear()：清空集合，移除所有元素
入参：无
返回：None

集合运算

集合运算：交集

交集运算
intersection()
操作符：&

集合运算：并集

并集运算
union()
操作符：｜

集合运算：差集

差集运算
difference()
操作符： -

集合推导式

类似列表推导式，同样集合支持集合推导式
语法：{x for x in ... if ...}

Dict 字典

字典定义

字典是无序的键值对集合
字典用大括号{}包围
每个键/值对之间用一个逗号分隔
各个键与值之间用一个冒号分隔
字典是动态的

字典使用：创建

创建字典
- 使用大括号填充键值对
- 通过构造方法 dict()
- 使用字典推导式

字典使用：访问元素

访问元素
- 与字典也支持中括号记法[key]。
- 字典使用键来访问其关联的值。
- 访问时对应的 key 必须要存在

字典使用：操作元素

语法：dict[key] = value
添加元素
- 键不存在
修改元素
- 键已经存在

字典使用：嵌套字典

嵌套字典
字典的值可以是字典对象

字典方法 keys()

keys()
返回由字典键组成的一个新视图对象。
入参：无

字典方法 values()

values()
返回由字典值组成的一个新视图对象。

字典方法 items()

items()
返回由字典项 ((键, 值) 对) 组成的一个新视图对象。

字典方法 get()

get(key)
获取指定 key 关联的 value 值。
入参：
- key：字典的键，必传。
返回：
- 如果 key 存在于字典中，返回 key 关联的 value 值。
- 如果 key 不存在，则返回 None。
此方法的好处是无需担心 key 是否存在，永远都不会引发 KeyError 错误。

字典方法 update()

update(dict)
使用来自 dict 的键/值对更新字典，覆盖原有的键和值。
入参：
- dict：字典对象，必传
返回：None

字典方法 pop()

pop(key)
删除指定 key 的键值对，并返回对应 value 值。
入参：
- key：必传
返回：
- 如果 key 存在于字典中，则将其移除并返回 value 值
- 如果 key 不存在于字典中，则会引发 KeyError。

字典推导式

字典推导式：可以从任何以键值对作为元素的可迭代对象中构建出字典。
实例：给定一个字典对象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。

# 未使用字典推导式的写法
dc = {'a': 1, 'b': 2, 'c': 3}
d_old = dict()
for k, v in dc.items():
    if v > 1:
        d_old[k] = v ** 2
print(d_old)

# 使用字典推导式
d_new = {k : v ** 2 for k,v in dc.items() if v > 1 }
print(d_new)

最后感谢每一个认真阅读我文章的人，礼尚往来总是要有的，虽然不是什么很值钱的东西，如果你用得到的话可以直接拿走：