列表表达式
俗话说“人生苦短，我用 Python”，Python 为了简化程序的代码行数做了很多努力，其中最经典的就是列表表达式。
比如我有如下函数，用来输出一个单词中的所有字符：
def output_letter(letter):
l = []
for item in letter:
l.append(item)
return l
if __name__ == "__main__":
print(output_letter('kevin'))
#此方法的输出为：
['k', 'e', 'v', 'i', 'n]
复制代码
Python 觉得这样写代码行数太多了，不优雅，于是有了如下的写法：
[expression for item in list]
复制代码
对应于我们的函数就变成了：
def output_letter(letter):
return [l for l in letter]
if __name__ == "__main__":
print(output_letter('kevin'))
#此方法的输出为：
['k', 'e', 'v', 'i', 'n']
复制代码
是不是瞬间少了很多代码，逻辑也更清晰？不仅如此，Python 还允许我们在列表表达式中进行判断。
[expression for item in list if xxx else yyy]
复制代码
例如我有一个列表，里面包括多个字符，我希望返回那些包含字母 k 的字符。
def output_letter(letter):
return [l for l in letter if 'k' in l]
if __name__ == "__main__":
print(output_letter(['kevin', 'did', 'automation', 'well']))
复制代码
列表表达式可以使我们的函数非常简洁易懂，并且减少代码量。
匿名函数
除了列表表达式可以减少代码量以外，Python 中还提供了匿名函数，当你的函数逻辑非常少时，你无须再定义一个函数，可采用匿名函数来减少代码量。匿名函数的语法如下：
lambda arguments : expression
复制代码
举例来说，我们有一个函数，用来得出列表中的每一个元素的平方，正常的写法是这样的：
def square(l):
square_list = []
for ele in l:
square_list.append(ele * ele)
return square_list
if __name__ == "__main__":
print(square([1, 2, 3, 4]))
复制代码
用了 lambda 后，是这样的：
a = lambda l: [item * item for item in l]
if __name__ == "__main__":
print(a([1, 2, 3, 4]))
复制代码
匿名函数大大地减少了代码工作量，但是也会让代码的可读性降低，所以通常逻辑不复杂的函数，可以考虑使用匿名函数。
自省/反射
在编程中，自省是一种在运行时查找有关对象的信息的能力；而反射则更进一步，它使对象能够在运行时进行修改。
自省和反射是 Python 中非常重要的概念，我们可以通过自省和反射来实现很多高级功能，例如动态查找待运行测试用例。
自省最经典的用法就是查看对象类型。
1.type
比如：
>>> type(7)
<class 'int'>
>>> type(2.0)
<class 'float'>
>>> type(int)
<class 'type'>
复制代码
type() 函数的返回值，我们称为类型对象，类型对象告诉我们参数属于哪种类对象实例。如上文所示，解释器便在告诉我们整数 7 属于 int 类，2.0 属于 float 类，而 int 属于类类型。
type() 常常跟函数isinstance() 配合使用，用来检测一个变量是否是我们需要的类型：
#下述例子判断给定的数字是否整型(int类)
x = 6
if isinstance(x, int):
print('I am int')
#你的逻辑
复制代码
自省还有以下其他几种用法。
2.dir
dir() 可以用来获取当前模块的属性列表，也可以获取指定一个属性。
if __name__ == "__main__":
my_list = [1, 2, 3]
print(dir(my_list))
print(dir(my_list).__class__)
复制代码
比如我们运行上述代码，则会有如下结果。
#第一个print返回
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
#第二个print返回
<class 'list'>
复制代码
3. id
id() 函数返回对象的唯一标识符。
if __name__ == "__main__":
name = "kevin"
print(id(name))
#输出
140245720259120
复制代码
4.inspect
inspect 模块提供了一些有用的函数帮助获取对象的信息，例如模块、类、方法、函数、回溯、帧对象，以及代码对象。
例如它可以帮助你检查类的内容，获取某个方法的源代码，取得并格式化某个函数的参数列表，或者获取你需要显示的回溯的详细信息。
inspect 有很多函数，我以一个实际例子为依托，介绍常用的几种。假设现在我们有个项目，它的文件结构是这样的：
testProject
--|tests
--|__init__.py
--|test1.py
--|test2.py
复制代码
其中，test1.py 的内容如下：
import inspect
from tests.test2 import hello
class KevinTest():
def __init__(self):
print('i am kevin cai')
def say_hello(self, name):
hello()
return 'Hello {name}'.format(name=name)
复制代码
test2.py 内容如下：
def hello():
print('hello from test2')
复制代码
inspect.getmodulename(path) 用来获取指定路径下的 module 名。
# 在test1.py中新增如下代码。
if __name__ == "__main__":
#此打印语句输出test1。 即当前模块名是test1
print(inspect.getmodulename(__file__))
复制代码
inspect.getmodule(object) 用来返回 object 定义在哪个 module 中。
# 在test1.py中新增如下代码。
if __name__ == "__main__":
#此语句输出<module 'tests.test2' from '/Users/kevin/automation/testProjectPython/tests/test2.py'>
print(inspect.getmodule(hello))
复制代码
inspect.getfile(object) 用来返回 object 定义在哪个 file 中。
# 在test1.py中新增如下代码。
if __name__ == "__main__"
test = KevinTest()
#此语句输出/Users/kevin/automation/testProjectPython/tests/test1.py
print(inspect.getfile(test.say_hello))
复制代码
inspect.getmembers(object) 用来返回 object 的所有成员列表（为 (name, value) 的形式）。
# 在test1.py中新增如下代码。
if __name__ == "__main__":
test = KevinTest()
#此语句输出test里的所有是方法的成员变量。输出是一个列表
#[('__init__', <bound method KevinTest.__init__ of <__main__.KevinTest object at 0x10911ef28>>), ('say_hello', <bound method KevinTest.say_hello of <__main__.KevinTest object at 0x10911ef28>>)]
print(inspect.getmembers(test, inspect.ismethod))
复制代码
闭包
闭包是一个概念，是指在能够读取其他函数内部变量的函数。这个定义比较抽象，我们来看一段代码：
def outer():
cheer = 'hello '
def inner(name):
return cheer + name
return inner
if __name__ == "__main__":
#输出hello kevin
print(outer()('kevin'))
复制代码
以上代码的意思如下：我定义了一个外部函数 outer 和一个内部函数 inner；在外部函数 outer 内部，我又定义了一个局部变量 cheer（并给定初始值为 hello）；然后我在内部函数 inner 里引用了这个局部变量 cheer。最后 outer 函数的返回值是 inner 函数本身。
在本例的调用里，outer 函数接受了两个参数，第一个参数为空，第二个参数为 kevin。那么 outer() 的返回值就是 inner。所以 outer()('kevin') 的返回值就是 inner('kevin')。
闭包的特点：
“闭包”这个概念非常重要，除了在 Python 中，闭包在 JavaScript、Go、PHP 等许多语言中都有广泛的应用。
而闭包在 Python 中的经典应用就是装饰器，而装饰器使 Python 代码能够夹带很多“私货”，下面我们就来看下装饰器的应用。
装饰器（decorator）
装饰器是闭包的一个经典应用。装饰器（decorator）在 python 中用来扩展原函数的功能，目的是在不改变原来函数代码的情况下，给函数增加新的功能。
1.实现装饰器
在我们的测试框架开发中，装饰器非常重要，它可以给函数添加 log 且不影响函数本身。
假设我们有一个函数 sum，作用是用来计算 N 个数字的和：
def sum(*kwargs):
total = 0
for ele in kwargs:
total = total + ele
return total
复制代码
现在，我们加了需求，需要记录这个函数开始的时间和结束的时间。
正常情况下，我们的代码是这样的：
import time
def sum(*kwargs):
print('function start at {}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ))
total = 0
for ele in kwargs:
total = total + ele
print('function end at {}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ))
return total
if __name__ == "__main__":
print(sum(1,2,3,4))
复制代码
后来，我们发现这个记录函数开始和结束时间的功能很好用，我们要求把这个功能加到每一个运行函数中去。
那么怎么办呢？难道要每一个函数都去加这样的代码吗？ 这样一点也不符合我们在前几节说的代码规范原则。
所以我们来稍做改变，把计算的函数 sum 的函数单独抽取出来不变，把时间处理的语句另行定义函数处理。于是上面的函数，就变成了以下的样子：
import time
def sum(*kwargs):
total = 0
for ele in kwargs:
total = total + ele
return total
def record_time(*kwargs):
print('function start at {}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ))
total = sum(*kwargs)
print('function end at {}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ))
return total
if __name__ == "__main__":
sum(1,2,3,4)
复制代码
以后我们再给函数加有关时间处理的功能，加到 record_time 里好了，而 sum 函数根本不用变。那这个函数还能更加简化吗？
结合我们刚刚讲过的闭包概念，我们用外函数和内函数来替换下：
record_time 就相当于我刚刚讲的 outer 函数，wrapper 函数就是 inner 函数，只不过我们的 inner 函数的入参是个函数，这样我们就实现了对函数本身功能的装饰。
import time
# 这个是外函数
def record_time(func):
def wrapper(*kwargs):
print('function start at {}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ))
total = func(*kwargs)
print('function end at {}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ))
return total
return wrapper
# 这个是我们真正的功能函数
def sum(*kwargs):
total = 0
for ele in kwargs:
total = total + ele
time.sleep(2)
return total
if __name__ == "__main__":
# 外函数，内函数，和功能函数一起，实现了不改变功能函数的前提下，给功能函数加功能的操作。
print(record_time(sum)(1,2,3,4))
复制代码
运行一下，测试结果为：
function start at 2020-08-14 01:06:49
function end at 2020-08-14 01:06:49
10
复制代码
假设我们的需求又变化啦，我们现在不统计函数的运行开始和结束时间了，改成统计函数的运行时长了，那么我们只需要改 record_time 这个函数就好了，而我们的功能函数 sum 就无须再改了，这样是不是方便了很多？
有了装饰器，我们可以在不改变原有函数代码的前提下，增加、改变原有函数的功能。这种方式也被称作“切面编程”，实际上，装饰器正是切面编程的最佳释例。
2.语法糖
不过你发现没，我们的调用仍然很麻烦，record_time(sum)(1,2,3,4)的调用方式，不容易让使用者理解我们这个函数是在做什么，于是 Python 中为了让大家写起来方便，给了装饰器一个语法糖，其用法如下：
@decorator
#对应我们的例子就是
@record_time
复制代码
使用语法糖后，在调用函数时，我们就无须再写这个装饰器函数了，转而直接写我们的功能函数就可以了，于是我们的例子就变成了：
import time
def record_time(func):
def wrapper(*kwargs):
print('function start at {}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ))
total = func(*kwargs)
print('function end at {}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ))
return total
return wrapper
#注意这一行，我们把record_time这个函数装饰到sum函数上。
@record_time
def sum(*kwargs):
total = 0
for ele in kwargs:
total = total + ele
time.sleep(2)
return total
if __name__ == "__main__":
#注意此次无须再写record_time了，这样有利于大家把关注点放在功能函数本身。
print(sum(1,2,3,4))`
复制代码
有了装饰器，我们就可以做很多额外的工作，例如插入日志、做事务处理等，在后续的章节中我也会介绍如何利用装饰器给测试用例打标签。
评论