软件测试/测试开发丨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)

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

这些资料,对于【软件测试】的朋友来说应该是最全面最完整的备战仓库,这个仓库也陪伴上万个测试工程师们走过最艰难的路程,希望也能帮助到你! 

你可能感兴趣的:(软件测试,python,数据结构,学习,功能测试,软件测试,自动化测试,程序人生)