Python函数式编程，函数装饰器

函数式编程

1. 定义：用一系列函数解决问题。

-- 函数可以赋值给变量，赋值后变量绑定函数。

-- 允许将函数作为参数传入另一个函数。

-- 允许函数返回一个函数。

2. 高阶函数：将函数作为参数或返回值的函数。

函数作为参数

将核心逻辑传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则。

def fun01():
  print("fun01执行执行喽")

# 有小括号,是调函数,a变量得到是函数返回值
# a = fun01()
# 没小括号,没调函数,a变量得到是函数地址
a = fun01
# 通过变量a,调用函数fun01.
a()
#fun01执行执行喽

def fun03():
  print("fun03执行执行喽")

def fun04():# 定义很多具体函数  [封装]
  print("fun04执行执行喽")

# func 代表(抽象)  fun03  fun04  [继承]
def fun02(func):
  print("fun02的逻辑")
  func()# 调用func执行....  [多态]

fun02(fun03)
#fun02的逻辑
#fun03执行执行喽
fun02(fun04)
#fun02的逻辑
#fun04执行执行喽

lambda 表达式

1.定义：是一种匿名方法。

2.作用：作为参数传递时语法简洁，优雅，代码可读性强。

3.语法

-- 定义：

变量 = lambda 形参: 方法体

-- 调用：

变量(实参)

4.说明：

-- 形参没有可以不填

-- 方法体只能有一条语句，方法体必须有返回值，且不支持赋值语句。

lambda 表达式
匿名方法
lambda 参数列表: 方法体

普通方法
def 方法名称(参数列表):
方法体
相对与普通方法的优缺点:
优点:省略方法名称，随时创建和销毁，降低了程序间耦合度
缺点:由于没有名称,所以不能重复使用.

list01 = [4,5,6,7,89]
def find(list_targt, func):
  for item in list_targt:
    if func(item):
      yield item
#普通方法
def condition01(item):
  return item % 2 == 0
for item in find(list01, condition01):
  print(item)

# 使用 lambda 代替普通方法
for item in find(list01, lambda item:item % 2 == 0):
  print(item)

内置高阶函数

1.map（函数，可迭代对象）：使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象。

2.filter(函数，可迭代对象)：根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。

3.sorted(可迭代对象，key = 函数,reverse = bool值)：排序，返回值为排序结果。

4.max(可迭代对象，key = 函数)：根据函数获取可迭代对象的最大值。

5.min(可迭代对象，key = 函数)：根据函数获取可迭代对象的最小值。

函数作为返回值

逻辑连续，当内部函数被调用时，不脱离当前的逻辑。

闭包

1.三要素：

-- 必须有一个内嵌函数。

-- 内嵌函数必须引用外部函数中变量。

-- 外部函数返回值必须是内嵌函数。

2.语法

-- 定义：

def 外部函数名(参数):

外部变量

def 内部函数名(参数):

使用外部变量

return 内部函数名

-- 调用：

   变量 = 外部函数名(参数)

   变量(参数)

def fun01():
  a = 1  # 对于fun02 而言,属于外部嵌套作用域

  def fun02():
    print(a)

  return fun02

# 闭包:
# 内部函数可以使用外部嵌套变量,外部函数执行完毕后,
# 没有释放内存,而是等待内部函数执行结束.
func = fun01()# 调用外部函数
func()# 再调用内部函数

def give_gife_money(money):
  """
    获取压岁钱
  """
  print("得到压岁钱:",money)
  def child_buy(target,price):
    """
      孩子需要买东西
    """
    nonlocal money
    if money >=  price:
      money -= price
      print("孩子需要花%d钱,买%s"%(price,target))
    else:
      print("钱不够")
  # 希望外部可以调用内部函数
  return child_buy

action_buy = give_gife_money(30000)
action_buy("飞机",1000)
action_buy("手机",10000)
action_buy("房子",10000000)
#得到压岁钱: 30000
#孩子需要花1000钱,买飞机
#孩子需要花10000钱,买手机
#钱不够

3.定义：在一个函数内部的函数,同时内部函数又引用了外部函数的变量。

4.本质：闭包是将内部函数和外部函数的执行环境绑定在一起的对象。

5.优点：内部函数可以使用外部变量。

6.缺点：外部变量一直存在于内存中，不会在调用结束后释放，占用内存。

7.作用：实现python装饰器。

函数装饰器decorators

1.定义：在不改变原函数的调用以及内部代码情况下，为其添加新功能的函数。

语法

2.def 函数装饰器名称(func):

    def 内嵌函数(*args, **kwargs):

        需要添加的新功能

        return func(*args, **kwargs)

return wrapper

@ 函数装饰器名称

def 原函数名称(参数):

函数体

原函数(参数)

3.本质：使用“@函数装饰器名称”修饰原函数，等同于创建与原函数名称相同的变量，关联内嵌函数；故调用原函数时执行内嵌函数。

原函数名称 = 函数装饰器名称（原函数名称）

4.装饰器链：

一个函数可以被多个装饰器修饰，执行顺序为从近到远。

def print_func_name(func):  # 提供旧功能
  def wrapper(*args, **kwargs):  # 包装
    print(func.__name__)  # 新功能
    return func(*args, **kwargs)  # 旧功能

  return wrapper


@print_func_name  # say_hello = print_func_name(say_hello)
def say_hello():
  print("hello")
  return "ok"


@print_func_name
def say_goodbye(name):
  print(name, "goodbye")


result = say_hello()
print(result)
say_goodbye("张无忌")
#--------------------------------
#say_hello
#hello
#ok
#say_goodbye
#张无忌 goodbye