一、map

作用

map: 自动将可迭代对象遍历，把遍历出来的数据，当成参数传入map第一个接口的函数中，将函数执行的结果，放到一个迭代器中进行返回

语法

map(function, iterable, ...)第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。iterable -- 一个或多个序列注意：map() 返回的是一个对象。如需展示列表，需手动 list() 转换。如果要打印返回的列表，需要加上list

res = map(lambda x: x * 2, [1, 2, 3, 4, 5])print(res)print(list(res))#输出结果

res2 = map(lambda x, y, z: {"sum": x + y}, [1, 2, 3, 4, 5], [11, 22, 33, 44, 55], [111, 222, 333])print(list(res2))#输出结果[{"sum": 12}, {"sum": 24}, {"sum": 36}]

map与zip组合使用

【资料图】

title = [    ["id","name","age"],    ["1","XM","18"],    ["2","XH","20"],    ["3","XG","19"],    ["4","GX","14"],]res1 = [i for i in map(lambda x:dict(zip(title[0],x)),title[1:]) if int(i["id"])>2]res2=list(map(lambda x:dict(zip(title[0],x)),title[1:]))print(res1)print(res2)#输出[{"id": "3", "name": "XG", "age": "19"}, {"id": "4", "name": "GX", "age": "14"}][{"id": "1", "name": "XM", "age": "18"}, {"id": "2", "name": "XH", "age": "20"}, {"id": "3", "name": "XG", "age": "19"}, {"id": "4", "name": "GX", "age": "14"}]

二、zip

作用

zip函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表（可迭代对象，可以用next取值）。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同利用 * 号操作符，可以将元组解压为列表注意：zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

li0 = [1, 2, 3, 4]li = [11, 22, 33, 44]li2 = [111, 222, 333, 444, 555, 666]res = zip(li)# 注意点：迭代器对象中的数据，迭代完就没有了print(next(res))print(list(res))#输出(11,)[(22,), (33,), (44,)]

li0 = [1, 2, 3, 4]li1 = [11, 22, 33, 44]li2 = [111, 222, 333, 444, 555, 666]res = zip(li1, li2)# 注意点：迭代器对象中的数据，迭代完就没有了print(list(res))# 三个参数res2 = zip(li0,li1, li2)print(list(res2))#输出[(11, 111), (22, 222), (33, 333), (44, 444)][(1, 11, 111), (2, 22, 222), (3, 33, 333), (4, 44, 444)]

语法

zip([iterable, ...]) ，iterabl -- 一个或多个迭代器;

nums = ["flower","flow","flight"]print(list(zip(*nums)))#输出[("f", "f", "f"), ("l", "l", "l"), ("o", "o", "i"), ("w", "w", "g")]

通过zip将两个列表合成字典

title = ["case_id", "case_title", "url", "data", "expected"]data = [1, "用例1", "www.baudi.com", "001", "ok"]res = zip(title,data)print(list(res))dic = dict(zip(title,data))print(dic)#输出[("case_id", 1), ("case_title", "用例1"), ("url", "www.baudi.com"), ("data", "001"), ("expected", "ok")]{"case_id": 1, "case_title": "用例1", "url": "www.baudi.com", "data": "001", "expected": "ok"}

应用举例：将excel读取出来的简单数据组装成接口测试用例所需的数据格式（键值对）

cases = [    ["case_id", "case_title", "url", "data", "excepted"],    [1, "用例1", "www.baudi.com", "001", "ok"],    [4, "用例4", "www.baudi.com", "002", "ok"],    [2, "用例2", "www.baudi.com", "002", "ok"],    [3, "用例3", "www.baudi.com", "002", "ok"],    [5, "用例5", "www.baudi.com", "002", "ok"],]title = cases[0]li = []for i in cases[1:]:    li.append(dict(zip(title, i)))print(li)#输出[{"case_id": 1, "case_title": "用例1", "url": "www.baudi.com", "data": "001", "excepted": "ok"}, {"case_id": 4, "case_title": "用例4", "url": "www.baudi.com", "data": "002", "excepted": "ok"}, {"case_id": 2, "case_title": "用例2", "url": "www.baudi.com", "data": "002", "excepted": "ok"}, {"case_id": 3, "case_title": "用例3", "url": "www.baudi.com", "data": "002", "excepted": "ok"}, {"case_id": 5, "case_title": "用例5", "url": "www.baudi.com", "data": "002", "excepted": "ok"}]

==================================================================================================================================================================

==================================================================================================================================================================

承接上文，我们来讲解管理器：

什么是上下文管理器？

我们常见的上下文管理器with open("test.txt", "w") as f:。with 语句是 Pyhton 提供的一种简化语法，适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，with 语句主要是为了简化代码操作。

with：文件使用后自动关闭

# 创建一个文件test.txt，若存在则打开，写入Hello Python# 创建/打开文件f = open("test.txt", "w")f.write("Hello Python")# 关闭这个文件f.close() # 使用withwith open("test.txt", "w") as f:    f.write("Python")

可以发现：通过 with 语句在编写代码时，会使代码变得更加简洁，不用再去关闭文件。

with的执行过程：

在执行 with 语句时，首先执行 with 后面的 open 代码

执行完代码后，会将代码的结果通过 as 保存到 f 中

然后在下面实现真正要执行的操作

在操作后面，并不需要写文件的关闭操作，文件会在使用完后自动关闭

上下文管理器实现原理：

with实际上是python中的关键字，它可以开启一个对象的上下文管理器协议，实际上，在文件操作时，并不是不需要写文件的关闭，而是文件的关闭操作在 with 的上下文管理器中的协议方法里已经写好了。当文件操作执行完成后， with语句会自动调用上下文管理器里的关闭语句来关闭文件资源。

简单来说，就是在一个类里，实现了__enter__和__exit__的方法，这个类的实例就是一个上下文管理器.

__enter__: 进入对象的上下文管理器调用的方法，会返回一个值，并赋值给as关键词之后的变量__exit__:退出对象的上下文管理器调用的方法，定义了处理结束后要做的事情，比如文件的关闭，socket的断开等例如这个示例：

#自定义一个上下文管理器，模拟with文件操作class MyOpen(object):    def __init__(self,path,mode,encoding="utf8"):        # 记录要操作的文件路径和模式        self.__path = path        self.__mode = mode        self.__encoding = encoding        # 打开文件        self.__handle = open(self.__path,self.__mode,encoding=self.__encoding)    def __enter__(self):        print("代码执行到了__enter__......")        # 返回打开的文件对象引用, 用来给  as 后的变量f赋值        return self.__handle     # 退出方法中，用来实现善后处理工作    def __exit__(self, exc_type, exc_val, exc_tb):        print("代码执行到了__exit__......")              self.__handle.close() # a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。with MyOpen("test.txt","a+") as f:    # 创建写入文件    f.write("Hello Python!!!")    print("文件写入成功")

我们执行一下，通过日志的打印顺序。可以知道其执行过程。

代码执行到了__enter__......文件写入成功代码执行到了__exit__......

上下文管理器的异常处理

异常可以在__exit__ 进行捕获并由你自己决定如何处理，是抛出还是不抛出。在__exit__ 里返回 True（没有return 就默认为 return False），就相当于告诉 Python解释器，这个异常我们已经捕获了，不需要再往外抛了。

在 写__exit__ 函数时，需要注意的事，它必须要有这三个参数：

exc_type：异常类型exc_val：异常值exc_tb：异常的错误栈信息

当主逻辑代码没有报异常时，这三个参数将都为None。

# 编写两个数做除法的程序，然后给除数穿入0class MyCount(object):    # 接收两个参数    def __init__(self,x, y):        self.__x = x        self.__y = y    # 返回一个地址（实质是被as后的变量接收），实例对象就会执行MyCount中的方法:div()    def __enter__(self):        print("代码执行到了__enter__......")        return self    def __exit__(self, exc_type, exc_val, exc_tb):        print("代码执行到了__exit__......")        if exc_type == None:            print("程序没问题")        else:            print("程序有问题，如果你能你看懂，问题如下：")            print("Type: ", exc_type)            print("Value:", exc_val)            print("TreacBack:", exc_tb)         # 返回值决定了捕获的异常是否继续向外抛出        # 如果是 False 那么就会继续向外抛出，程序会看到系统提示的异常信息        # 如果是 True 不会向外抛出，程序看不到系统提示信息，只能看到else中的输出        return  True     def div(self):        print("代码执行到了除法div")        return self.__x / self.__y  with MyCount(1, 0) as mc:    mc.div()

输出如下