函数

特殊函数的使用之 filter：

_接收一个序列，将序列中的每一个元素传入到提供的函数中进行判断，如果函数的返回值为 True 那么将这个元素添加到新的序列中

  1. # 筛选出所有的字符
  2. def filter_alpha(param):
  3.     # 传入了所有的元素，但是只留下了返回值为 True 的
  4.     print(param)
  5.     # isalpha 是 str 的一个成员方法，用于判断是否是字母
  6.     # islower 是 str 的一个成员方法，用于判断是否是小写
  7.     return param.isalpha() and param.islower()
  9. print(list(filter(filter_alpha, "A1!b2#C3%d4^E5&f6")))

特殊函数的使用之 reduce：

_接收一个序列和函数，函数必须拥有两个参数。首先将序列的第一个元素和第二个元素作为参数传 入到函数中，之后的每一次都将前一次的计算结果和下一个元素传入到函数中，最终返回计算结果

  1. # 必须要有两个参数
  2. def add(number1, number2):
  3.     return number1 + number2
  5. def mul(number1, number2):
  6.     return number1 * number2
  8. # 在 Python3 中 reduce 函数不再是内置函数，需要使用 fucntools
  9. # 模块才能够调用到 reducue 函数
  10. from functools import reduce
  12. # range 生成了 0~99，第一次将 0 和 1 传入到 add，返回 1，第二
  13. # 次将 1 和 2 传入到函数返回3， 第三次将3 和 3 再次传入，直到
  14. # 整个序列计算完毕
  15. print(reduce(add, range(101)))
  16. print(reduce(mul, range(1, 100)))

特殊函数的使用之 map：

_map 要求传入一个函数以及一个或多个的可迭代序列，函数的参数个数必须和序列的数量相同，mao会在内部分别将每一个序列的元素传入到提供的函数中，并且把函数的返回值组合成一个新的可迭代序列

  1. def rep_string(s, time):
  2.     return s * time
  3. print(list(map(rep_string, "abcd", [1, 2, 3, 4])))

lambda 表达式的语法

_lambda 参数名 : 实现实现部分只能有一条语句，且不能有 return ,整个实现部分的结果就是函数的返回值

  1. print(list(map(lambda a, b:a*b, "abcd", [1, 2, 3, 4])))
  2. print(reduce(lambda x, y: x*y, range(1,101)))
  3. print(list(filter(lambda n: True if n.isalpha() else False, "A1!b2#C3%d4^E5&f6")))

高阶函数的使用之【闭包】：

_闭包指内部函数使用外部函数作用域的变量

  1. def outer(factor):
  2.     # 作用域：其中有 factor 和 inner
  3.     def inner(number):
  4.         # 作用域，其中有 number
  5.         return number * factor
  6.     # 返回了一个函数
  7.     return inner
  9. fun = outer(10)
  10. """
  11.     在执行以上代码的时候，会返回一个内部函数
  12.         def inner(number):
  13.             return number * 10
  14. """
  16. print(fun(20))
  17. """
  18.     fun 接受了上一个函数的返回值，已经是一个函数了
  19.         def inner(20):
  20.             return 20 * 10
  21. """

装饰器：

_在闭包的基础上，内部函数调用了# 外部作用域提供的函数。

  1. def outer(func):
  2.     def inner():
  3.         print("执行之前的时间")
  4.         func()
  5.         print("执行之后的时间")
  6.     return inner
  9. # 有些时候，我们需要给一些特定的函数添加功能，
  10. # 但是不能修改函数的名称，函数的参数个数以及
  11. # 函数的调用形式，可以使用装饰器实现功能
  12. # @outer              # 在 Python 中 @ 的是语法糖
  13. def f1():
  14.     print('f1: 原有的功能')
  15. # 传入了一个函数，返回了一个新的函数，并且
  16. # 将新函数的地址赋值给 f1。
  17. f1 = outer(f1)
  18. """
  19.  def inner():
  20.     print("这里是在原有函数上新添加的功能")
  21.     return 以前的f1()
  22. """
  23. f1()
  24. """ 这里是返回的新的函数
  25. def f1():
  26.     print("这里是在原有函数上新添加的功能")
  27.     return 以前的f1()
  28. """
  30. # 语法糖就是为了让代码可读性更高使用更简单
  31. # arr[10][10]  ->   *(*(arr+10)+10)