【Python内置函数map和zip+上下文管理器及其实现原理】

一、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))

#输出结果
<map object at 0x00000208F7F27630>
[2, 4, 6, 8, 10]

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()

# 使用with
with 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。

# 编写两个数做除法的程序，然后给除数穿入0
class 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()

输出如下