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

谁借莪１个温暖的怀抱￠ 2023-09-27 22:25 79阅读 0赞

**一、理解python数据结构** 1、 python不仅提供了一流的标准库，还提供了四个强大的内置数据结构，分别是：列表，元组，集合，字典，用来保存对象的集合 P.S. 内置：指的是在代码之中可以直接使用，不用再import导入，也就是说他们是语言的一部分 2、该怎么选择所需的数据结构呢？ a.使用一种有序的方式呈现数据，列表和元组就很不错 b.如果数据的顺序不重要，而追求唯一性，那么集合就特别适合，不过有的时候数据的结构特别关键，需要方便描述和查找对象，例如测试用例的详细信息，包括用例标号，优先级和预期结果等等，这种情况下则需要考虑字典。

**二、list列表** 1、列表的定义与使用

![format_png][]

#使用中括号包起来的元素就叫做列表
    var_list = [1,2,3,"a","b","c",True]
    print(var_list)
    #前闭后开原则 start：stop：step
    print(var_list[2:-2])
    print(var_list[2::2])
    
    # 1、构建方法 list()
    li = list()
    print(type(li), li)
    
    li1 = list("hogwards")
    print(type(li1), li1)
    
    # 2、中括号填充元素[]
    li2 = [1, 2, 3]
    li3 = ['hello', 'world']
    li4 = [1, 3.14, 'hogwards', [5, 6, 7]]
    print(li4)
    
    # 列表推导式
    
    li5 = [i for i in range(1, 10) if i % 2 == 0]
    print(type(li5), li5)
    
    # 列表使用 索引
    li6 = [1, 2, 3, 4, 5, 6]
    # 1、正向索引
    print(li6[2])
    # 2、反向索引
    print(li6[-3])
    
    # 1、重复
    li_1 = [1] * 5
    li_1_1 = ["shirley"] * 5
    print(li_1)
    print(li_1_1)
    
    # 2、合并
    li_2 = [1, 4, 7]
    li_3 = [10, 44, 00]
    print(li_2 + li_3)
    
    # in & not in
    li_4 = [1, 4, 7, 8]
    print(1 in li_4)
    print(10 in li_4)
    print(1 not in li_4)
    print(30 not in li_4)

2、列表的常用方法

a、扩展类方法：主要是往列表中添加新的元素

![format_png 1][]

# append（）方法
    li_5 = []
    print(li_5.append(100))
    print(len(li_5), li_5)
    li_5.append('Shirley_Testing')
    print(len(li_5), li_5)
    
    # extend（）方法
    # 注意extend字符串和列表的区别
    li_6 = []
    li_6.extend(['hello', 'world'])
    li_6.extend('beautiful')
    print(len(li6), li_6)
    li_7 = ['shirley', 'test', 'wonderful']
    li_6.extend(li_7)
    print(len(li_6), li_6)
    
    # insert（）方法
    li_8 = [1, 2, 3, 4, 5]
    li_8.insert(3, 100)
    print(li_8)
    li_8.insert(2, 'hello wprld')
    print(li_8)

b.收缩方法：用来移除列表中现有的元素

![format_png 2][]

# pop()方法
    li_9 = [5, 34, 22, 6, 7, 9, 65]
    test_pop = li_9.pop()
    print(test_pop)
    print(li_9)
    
    print(li_9.pop(3))
    print(li_9)
    # IndexError：pop index out of range
    # 对空列表执行pop方法
    # 索引超出范围
    
    # remove()方法
    li_10 = ['Effy', 'is', 'is', 'a', 'very', 'very', 'beautiful', 'girl']
    li_10.remove('is')
    print(li_10)
    li_10.remove('very')
    print(li_10)
    # 如果元素不存在，去使用remove方法，则会报一个值错误的异常
    # ValueError: list.remove(x): x not in list
    # li_10.remove('wonderful')
    # print(li_10)

c.排序

![format_png 3][]

# sort()方法
    li_11 = [1, 4, 6, 8, 9, 0, 2]
    li_11.sort()
    print(li_11)
    li_11.sort(reverse=True)
    print(li_11)
    
    li_12 = ['Effy', '9887676', 'wonderful', 'awesome', '2']
    li_12.sort(key=len)
    print(li_12)
    # 如果列表中有字符串又有数字，则会报错
    # TypeError: object of type 'int' has no len()

d.反转

![format_png 4][]

# reverse（）方法
    li_13 = [4,2,7,5,8,0,11]
    li_13.reverse()
    print(li_13)
    # [11, 0, 8, 5, 7, 2, 4]

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

# 创建嵌套列表
    li_14 = [[1,2,3],['hello','world','python']]
    print(li_14[1][2])
    li_14.append("test")
    print(li_14)

f.列表推导式：列表推导式指循环创建列表，相当于for循环创建列表的简化版

语法：\[for x in li if x ...\]

# 列表推导式
    li_15 = [1,2,3,4,6,7,8,9]
    data = [i for i in li_15 if i%2==0]
    print(data)
    
    # for循环 普通写法
    result = []
    for i in range (1,11):
        if i % 2 == 0:
            result.append(i**2)
            print(result)
    # 列表推导式写法
    
    data = [i**2 for i in range(1,11) if i % 2 == 0]
    print(data)

**三、tuple元组** 1、元组的定义与使用

![format_png 5][]

#1、直接使用逗号分隔
    tup1 = 1,2,3,4,5
    print(type(tup1),tup1)
    
    # 2、通过小括号填充元素
    tup2 = (6,7,8,9,10)
    print(type(tup2),tup2)
    
    # 3、通过构造函数tuple()
    tup3 = tuple()
    print(type(tup3),tup3)
    
    tup4 = tuple("effy")
    print(type(tup4),tup4)
    
    tup5 = tuple([1,123])
    print(type(tup5),tup5)
    
    # 只有一个元素时，末尾需要加一个逗号
    tup6 = 1,
    print(type(tup6),tup6)
    
    tup7 = tuple([4635635])
    print(type(tup7),tup7)
    
    # 不加逗号，会是一个int类型
    tup8 = (10)
    print(type(tup8),tup8)
    
    
    # 元组索引
    
    tup9 = tuple("beautiful")
    # 1、正向索引
    print(tup9[2])
    # 1、反向索引
    print(tup9[-1])
    
    # 切片的使用
    
    tup10 = tuple("frustrated")
    print(tup10)
    print(tup10[0:3:1])
    print(tup10[:])
    print(tup10[:-2])
    print(tup10[2:5:2])
    
    # 特殊的切片写法：逆序
    print(tup10[::-1])

2、元组常用方法

![format_png 6][]

# index方法
    tup11 = tuple("frustrated")
    print(tup11.index('t'))
    # 输入元组中不存在的数据
    # ValueError: tuple.index(x): x not in tuple
    # print(tup11.index('X'))
    
    # count()方法
    tup12 = tuple("nicenicewonderful")
    print(tup12.count("n"))
    print(tup12.count("d"))
    print(tup12.count("2"))
    print(tup12.count("c"))

3、解包

# 元组解包
    tup13 = 1,2,3
    # 1、传统逐个赋值的方式
    a = tup13[0]
    b = tup13[1]
    c = tup13[2]
    print(a,b,c)
    print(type(a))
    
    # 解包平行赋值
    a,b,c = (1,2,3)
    print(a,b,c)
    print(type(a))

4、元组与列表

相同点： 都是有序的； 都是异构的，能够包含不同类型的对象； 都支持索引和切片

区别： 声明方式不同，元组使用()，列表使用\[\]; 列表是可变的，元组是不可变的

**四、集合** 1、集合的定义与使用

![format_png 7][]

# 集合：无序，去重
    # 1通过使用{}填充元素
    set_1 = {1,2,3}
    print(type(set_1),set_1)
    # <class 'set'> {1, 2, 3}
    
    # 2通过构造方法 set{iterable}
    # 传入字符串
    set_2 = set("learning python")
    print(type(set_2),set_2)
    # <class 'set'> {'p', 'o', 'g', 'r', 'l', ' ', 'y', 't', 'e', 'h', 'i', 'a', 'n'}
    
    # 传入列表或者元组
    set_3 = set([2,5,7,8,7])
    print(type(set_3),set_3)
    # <class 'set'> {8, 2, 5, 7}
    
    set_4 = set((6,7,8,6))
    print(type(set_4),set_4)
    # <class 'set'> {8, 6, 7}
    
    # 使用构造方法，不传任何参数时，将会创建一个空的集合对象
    set_5 = set()
    print(type(set_5),set_5)
    # <class 'set'> set()
    
    # 3、通过集合推导式
    # 获取0，1，2，3，4中的偶数部分来构造集合对象
    set_6 = {i for i in range(5)if i %2 ==0}
    print(set_6)
    # {0, 2, 4}
    
    # # 获取0，1，2，3，4中的奇数部分的幂方来构造集合对象
    set_7 = {i**2 for i in range(5) if i % 2 !=0}
    print(set_7,type(set_7))
    # {1, 9} <class 'set'>
    
    
    # in：判断元素是否是在集合中存在
    # not in：判断元素是否是集合中不存在
    set_8 = {"python","234343"}
    print("python" in set_8)
    # True
    print("test" in set_8)
    # False
    print("test" not in set_8)
    # True

2、集合常用方法

a.扩展类方法

![format_png 8][]

# 集合方法add(itme)
    set_9 = set()
    set_9.add(1)
    set_9.add("wonderful")
    set_9.add(3)
    print(set_9)
    # {1, 3, 'wonderful'}
    
    # 集合方法update()
    # 使用update方法传入一个字符串
    set_9.update("wonderful")
    print(type(set_9),set_9)
    # <class 'set'> {1, 3, 'w', 'n', 'e', 'f', 'l', 'o', 'r', 'd', 'wonderful', 'u'}
    
    # 使用update方法传入一个列表
    set_9.update([2,4,6,8])
    print(set_9,type(set_9))
    #{'n', 1, 2, 3, 4, 6, 'u', 8, 'wonderful', 'o', 'w', 'r', 'd', 'f', 'l', 'e'} <class 'set'>

b.收缩类方法

![format_png 9][]

# 集合方法remove()
    set_10 = {1,4,6,'totally'}
    set_10.remove(6)
    print(set_10)
    # {1, 'totally', 4}
    
    # remove一个不存在的值，则会报错
    # set_10.remove(100)
    # print(set_10)
    #
    #     set_10.remove(100)
    # KeyError: 100
    
    # 使用remove方法，每次嗨必须确保元素必须在集合中存在，如果嫌麻烦可以使用discard方法
    
    # 集合方法discard()
    set_11 = {46,34,75,"test"}
    set_11.discard(100)
    print(set_11,type(set_11))
    # {34, 75, 46, 'test'} <class 'set'>   即使元素不存在，不会报错
    
    set_11.discard(75)
    print(set_11,type(set_11))
    # {34, 46, 'test'} <class 'set'>  元素存在，直接移除
    
    # 集合方法 pop()
    set_12 = {6,7,2,"Effy"}
    print(set_12.pop())
    # 2
    print(set_12)
    # {'Effy', 6, 7}
    
    # 集合方法 clear()
    set_13 = {3,2,7,4,"hello","world"}
    set_13.clear()
    print(set_13)
    # set()

c.集合运算

![format_png 10][]

# 集合运算
    # 交集运算  intersection()  操作符 &
    set_14 = {1,5,7,9}
    set_15 = {6,2,9,11}
    data = set_14.intersection(set_15)
    print(data)
    # {9}
    
    # 也可以使用 & 符号
    print(set_14 & set_15)
    # {9}
    
    #并集运算  union()   操作符 |
    set_16 = {1,2,4,6,7}
    set_17 = {6,9,8}
    print(set_16.union(set_17))
    # {1, 2, 4, 6, 7, 8, 9}
    
    print(set_16 | set_17)
    # {1, 2, 4, 6, 7, 8, 9}
    
    #差集运算  difference()   操作符 -
    set_18 = {1,2,3,5,6,7}
    set_19 = {1,3,5,7,8,9,10}
    print(set_18.difference(set_19))
    # {2, 6}
    print(set_18 - set_19)
    # {2, 6}
    
    print(set_19.difference(set_18))
    # {8, 9, 10}
    print(set_19 - set_18)
    # {8, 9, 10}

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

# 集合推导式
    print({i for i in range(10) if i%2==0})
    # {0, 2, 4, 6, 8}
    # 实例 寻找 beautiful 和wonderful的共同字母
    # 一般for循环
    set_20 = set()
    for i in "beautiful":
        if i in "wonderful":
            set_20.add(i)
    print(set_20)
    # {'l', 'f', 'e', 'u'}
    
    # 推导式（使代码非常的简洁）
    print({i for i in "beautiful" if i in "wonderful"})
    # {'e', 'l', 'f', 'u'}

**五、dict字典** 1、字典定义与使用

![format_png 11][]

"""
    字典
    字典的键：通常是一个字符串，关联的值可以是任意的python对象，包括字符串，列表，元组，集合和字典等等；
    在字典中，每一个唯一键有与之相关联的值；
    字典可以有多个键值对，与键关联的值可以是任意的对象
    关于键和值有一定的约束条件：e.g.字典的键可以是任意不可变的类型，通常是字符串和数值，在同一个字典层级内，
    键必须是唯一的，不能出现重复，字典的值则可以是任意的python对象，比如字符串，列表，元组，集合，还可以是另一个字典对象等等；
    """
    
    """ 字典使用：创建"""
    """1、使用大括号填充键值对"""
    dict_1 = {"name":"Kety perry","age":18}
    print(type(dict_1),dict_1)
    # <class 'dict'> {'name': 'Kety perry', 'age': 18}
    
    # 如果不赋值，则会得到一个空的字典对象
    dict_2 = {}
    print(type(dict_2),dict_2)
    # <class 'dict'> {}
    
    """2、使用字典的构造方法- 使用dict关键字"""
    
    dict_3 = dict()
    # 传入可迭代的对象，一般是类似于键和值成对出现的数据，如果不填的话，会得到一个空的字典
    print(type(dict_3),dict_3)
    # <class 'dict'> {}
    dict_4 = dict([("name","Taylor Swift"),("age",22)])
    print(dict_4,type(dict_4))
    # {'name': 'Taylor Swift', 'age': 22} <class 'dict'>
    
    """3、字典推导式"""
    dict_5 = {i:j for i,j in [("name","Taylor Swift"),("age",22)]}
    print(dict_5,type(dict_5))
    # {'name': 'Taylor Swift', 'age': 22} <class 'dict'>
    
    """字典使用：访问元素"""
    dict_6 = {'name': 'Taylor Swift', 'age': '22'}
    # 访问存在的key
    print(dict_6['name'])
    # Taylor Swift
    print(dict_6["age"])
    # 22
    
    # 访问不存在的key
    # print(dict_6["hobby"])
    # KeyError: 'hobby'
    
    """操作元素"""
    dict_7 =  {'name': 'Taylor Swift', 'age': '22'}
    
    # 赋值已存在的key
    dict_7["name"] = "Adele"
    print(dict_7)
    # {'name': 'Adele', 'age': '22'}
    dict_7["age"] = 27
    print(dict_7)
    # {'name': 'Adele', 'age': 27}
    
    # 赋值不存在的key,实现新增一个键值对的操作
    dict_7["hobby"] = "dancing"
    print(dict_7)
    # {'name': 'Adele', 'age': 27, 'hobby': 'dancing'}
    
    
    """字典使用 嵌套字典"""
    # 在我们的测试工作中，经常打交道的接口响应报文，一般都是这种嵌套的复杂的字典结构
    # 访问元素和操作嵌套字典的元素是一样的道理
    dict_8 = {"name":"Taylor Swift","class":"六年二班","course":{"English":100,"Chinese":98,"Math":94}}
    # 获取课程Chinese的分数
    print(dict_8["course"]["Chinese"])
    # 98
    # 将课程数学分数改成100
    dict_8["course"]["Math"] = 100
    print(dict_8["course"]["Math"])
    print(dict_8)
    # 100
    # {'name': 'Taylor Swift', 'class': '六年二班', 'course': {'English': 100, 'Chinese': 98, 'Math': 100}}

2、字典常用方法

![format_png 12][]

"""字典常用方法"""
    """keys() | values() | items()"""
    dict_9 = {"name":"Taylor Swift","class":"六年二班","course":"python"}
    print(dict_9.keys())
    # dict_keys(['name', 'class', 'course'])
    
    print(dict_9.values())
    # dict_values(['Taylor Swift', '六年二班', 'python'])
    
    print(dict_9.items())
    # dict_items([('name', 'Taylor Swift'), ('class', '六年二班'), ('course', 'python')])
    
    # 转化成列表
    print(list(dict_9.keys()))
    print(list(dict_9.values()))
    print(list(dict_9.items()))
    
    # ['name', 'class', 'course']
    # ['Taylor Swift', '六年二班', 'python']
    # [('name', 'Taylor Swift'), ('class', '六年二班'), ('course', 'python')]
    
    
    """get(key)"""
    dict_10 = {"name":"Taylor Swift","class":"六年二班","course":"python"}
    # 1、访问存在的key
    print(dict_10.get("name"))
    print(dict_10.get("course"))
    # Taylor Swift
    # python
    
    # 2、访问不存在的key
    print(dict_10.get("hobby"))
    # None
    
    
    """update()"""
    dict_11 = {"name":"Taylor Swift","class":"六年二班","course":"python"}
    dict_12 = {"age":20,"course":"Java"}
    dict_11.update(dict_12)
    print(dict_11)
    # {'name': 'Taylor Swift', 'class': '六年二班', 'course': 'Java', 'age': 20}
    
    
    """pop()"""
    dict_13 =  {'name': 'Taylor Swift', 'class': '六年二班', 'course': 'Java', 'age': 20}
    # 1、删除已经存在的Key
    dict_14 = dict_13.pop("course")
    print(dict_13)
    # {'name': 'Taylor Swift', 'class': '六年二班', 'age': 20}
    print(dict_14)
    # Java
    
    # 2、删除不存在的key,会抛错
    # dict_13.pop("hobby")
    # print(dict_13)
    # KeyError: 'hobby'

3、字典推导式：字典推导式：可以从任何以键值对作为元素的可迭代对象中构建出字典。

"""实例：给定一个字典对象{'a':1,'b':2,'c':3}，找出其中所有大于1 的键值对，同时value进行平方运算"""
    dict_15 = {'a':1,'b':2,'c':3}
    dict_16 = {k:v**2 for k,v in dict_15.items() if v>1}
    print(dict_16)
    # {'b': 4, 'c': 9}
    
    # 普通for循环
    dict_17 = {'a':1,'b':2,'c':3}
    dict_18 = {}
    for k,v in dict_17.items():
        if v > 1:
            dict_18[k]=v**2
    print(dict_18)
    
    # {'b': 4, 'c': 9}
    
    """
    实例：给定一个字典对象，请使用字典推导式，将它的key和value分别进行交换，也就是key变成值，值变成key
    输入：{'a':1,'b':2,'c':3}
    输出：{1: 'a', 2: 'b', 3: 'c'}
    """
    dict_19 = {'a':1,'b':2,'c':3}
    dict_20 = {v:k for k,v in dict_19.items()}
    print(dict_19)
    print(dict_20)
    # {1: 'a', 2: 'b', 3: 'c'}

**最后：**下方这份完整的软件测试视频学习教程已经整理上传完成，需要的朋友们可以自行领取**【保证100%免费】**

![在这里插入图片描述][9d205f76a3bb49d8bce29972548618fa.png_pic_center]

### 软件测试面试文档 ###

我们学习必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有字节大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

![图片][5edae9a0b47e4dfc8a71a369c5468e60.png]

#### 整套资料获取 ####

![369a983c462d44889b8ad60237393e76.gif][]

[format_png]: https://img-blog.csdnimg.cn/img_convert/74588af515c7ecdc6a332fdc27b0c4c6.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/d6bc92b2df28d79b44bfca2df1058f72.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/a0de7a37b6dd84342f38233b9062fa59.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/7f97b6f0c40789cc2e21164bcf83191a.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/18656026e7927cbde58dafdb5c0b55f5.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/aa65f5b1f37fca4412e19872a4d03053.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/eb95b4550f8a01a1b72d25442339cfa0.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/ab4c3c1273dc58c6ddcec99425b40198.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/5e9e66624c3f899ff96220a874fb0f1c.webp?x-oss-process=image/format,png
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/988f5abb1ed12be32ca2f78bc96a4f48.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/6d80467d93502a60e15da639e61f1ddf.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/4375e80c0c4459d40304d384d82af8f9.webp?x-oss-process=image/format,png
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/9566960a30cf18bb5e3534cba877e326.webp?x-oss-process=image/format,png
[9d205f76a3bb49d8bce29972548618fa.png_pic_center]: https://img-blog.csdnimg.cn/9d205f76a3bb49d8bce29972548618fa.png#pic_center
[5edae9a0b47e4dfc8a71a369c5468e60.png]: https://img-blog.csdnimg.cn/5edae9a0b47e4dfc8a71a369c5468e60.png
[369a983c462d44889b8ad60237393e76.gif]: https://img-blog.csdnimg.cn/369a983c462d44889b8ad60237393e76.gif