Python小技巧：如何用更少的代码做更多的事情

经常在写代码的时候，会写很多代码，但是有时候只要是使用妥当，一行代码就可以代替，也就是很简单的一行代码就能实现。

1.短路运算，常见的就是if els组成的

2. def get_user(user):

4. # 常规代码

6. if user:

8. return user

10. return "匿名用户"

13. if __name__=="__main__":

15. print(get_user(None))

17. # 短路来简写代码

20. def get_user(user):

22. return user or "匿名用户"

24. if __name__=="__main__":

26. print(get_user(None))

结果打印

1. 匿名用户

2. 匿名用户

这样只需要一行代码久可以搞定了。

2.切片替代循环

使用切片代替循环或递归来操作序列。切片是一种用于从一个序列（如字符串、列表、元组等）中获取一部分或全部元素的语法。

2. # 使用循环

4. def reverselist(lst):

6. new_lst = []

8. for i in range(len(lst) - 1, -1, -1):

10. new_lst.append(lst[i])

12. return new_lst

15. lst = [1, 2, 3, 4, 5]

17. print(reverselist(lst)) # [5, 4, 3, 2, 1]

20. # 使用切片

22. def reverselist(lst):

24. return lst[::-1]

27. lst = [1, 2, 3, 4, 6]

29. print(reverselist(lst)) # [6, 4, 3, 2, 1]

切片的操作比循环或递归更简单并且高效，因为切片是基于内置函数实现的，而循环或递归是基于自定义函数实现。

3.枚举

枚举是一种用于同时获取可迭代对象中的元素和索引的函数。枚举可以避免使用额外的变量来记录索引，提高了代码的可读性和效率。

2. # 使用普通的循环

4. lst = ["a", "b", "c", "d", "e"]

6. index = 0

8. for x in lst:

10. print(index, x)

12. index += 1

打印

2. # 输出：

4. # 0 a

6. # 1 b

8. # 2 c

10. # 3 d

12. # 4 e

'

运行

运行

使用枚举来实现

2. # 使用枚举

4. lst = ["a", "b", "c", "d", "e"]

6. for index, x in enumerate(lst):

8. print(index, x)

10. # 输出：

12. # 0 a

14. # 1 b

16. # 2 c

18. # 3 d

20. # 4 e

使用枚举更加清晰，更加简洁

4.三元运算符

三元运算符是一种用于根据一个条件表达式来选择两个不同的值的简洁的语法。

2. # 使用普通的if-else语句

4. num = -5

6. if num > 0:

8. sign = "positive"

10. else:

12. sign = "negative"

14. print(sign) # negative

16. # 使用三元运算符

18. num = -5

20. sign = "positive" if num > 0 else "negative"

22. print(sign) # negative

'

运行

运行

5.字典处理条件判断

遇到if循环语句很长的时候，其实可以使用字典来替代

2. # 使用多个if-elif-else语句

4. def foo(x):

6. if x == "a":

8. return 1

10. elif x == "b":

12. return 2

14. elif x == "c":

16. return 3

18. else:

20. return -1

23. print(foo("a")) # 1

25. print(foo("d")) # -1

28. # 使用字典

30. def foo(x):

32. dic = {"a": 1, "b": 2, "c": 3}

34. return dic.get(x, -1)

37. print(foo("a")) # 1

39. print(foo("d")) # -1

6.map 函数

map函数代替循环来对可迭代对象中的每个元素应用一个函数。map函数是一种用于将一个函数作用于一个可迭代对象中的每个元素，并返回一个新的可迭代对象的函数。

2. # 不使用map函数

4. lst = ["1", "2", "3", "4", "5"]

6. new_lst = []

8. for x in lst:

10. new_lst.append(int(x))

12. print(new_lst) # [1, 2, 3, 4, 5]

15. # 使用map函数

17. lst = ["1", "2", "3", "4", "5"]

19. new_lst = list(map(int, lst))

21. print(new_lst) # [1, 2, 3, 4, 5]

7.filter 函数

filter函数代替循环来从可迭代对象中筛选出满足一个条件的元素。filter函数是一种用于将一个条件函数作用于一个可迭代对象中的每个元素，并返回一个只包含满足条件元素的新的可迭代对象的函数。

例如：查找奇偶数

2. # 不使用filter函数

4. lst = [1, 2, 3, 4, 5]

6. new_lst = []

8. for x in lst:

10. if x % 2 == 0:

12. new_lst.append(x)

14. print(new_lst) # [2, 4]

17. # 使用filter函数

19. lst = [1, 2, 3, 4, 5]

21. new_lst = list(filter(lambda x: x % 2 == 0, lst))

23. print(new_lst) # [2, 4]

8.装饰器

装饰器是一种用于在不修改原函数定义和调用的情况下，给函数添加额外的功能或修改其行为的语法。

2. # 使用普通的函数调用

4. import time

7. def foo():

9. # do something

11. time.sleep(1)

14. start = time.time()

16. foo()

18. end = time.time()

20. print(f"foo() fun run {end - start} seconds.")

如果用装饰器呢

2. # 使用装饰器

4. import time

7. def timer(func):

9. def wrapper(*args, **kwargs):

11. start = time.time()

13. result = func(*args, **kwargs)

15. end = time.time()

17. print(f"{func.__name__}() took {end - start} seconds to run.")

19. return result

21. return wrapper

24. @timer # 相当于 foo = timer(foo)

26. def foo():

28. # do something

30. time.sleep(1)

这个装饰器不仅这个函数能用，其他函数也可以用。比如flask 框架，装饰器用到很多。还可以实现，如日志、缓存、计时、权限检查等。使用起来还是很方便呢。比如在测试中，之前我还自己简单写了一个巡检系统，不用定时器，自己用装饰器实现一个定时器，很简单的一两行代码不用依赖，只要有python环境随时可以执行了。当然了，还可以有很多用途。

python以简洁之美著称，所以在实际的开发中，我们还是可以多用到这些高级的语法，可以很简洁的实现功能。

总结：

感谢每一个认真阅读我文章的人！！！

作为一位过来人也是希望大家少走一些弯路，如果你不想再体验一次学习时找不到资料，没人解答问题，坚持几天便放弃的感受的话，在这里我给大家分享一些自动化测试的学习资源，希望能给你前进的路上带来帮助。

软件测试面试文档

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

 

          视频文档获取方式：
这份文档和视频资料，对于想从事【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！以上均可以分享，点下方小卡片即可自行领取。