python基础之函数式编程

一、定义：

　　

　　函数作为参数作用：将核心逻辑传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则；

　　函数作为返回值作用：逻辑连续，当内部函数被调用时，不脱离当前的逻辑。

二、高阶函数：

　　1、定义：将函数作为参数或返回值的函数。

　　2、常见内置高阶函数：

　　　　

三、lambda表达式：

　　

四、闭包：

　　

五、函数装饰器（decorators）：

　　

六、基础代码：

　　代码1：

　　

"""
    函数式编程　－－　方法作为参数
"""

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

# 调用fun01，将返回值赋值给变量ａ
# a = fun01()

# 将函数值赋值给变量ａ（没有执行fun01）
a = fun01
# 调用变量ａ，间接执行函数fun01
a()

# 将方法fun01作为方法的参数func进行传递
def fun02(func):
    print("fun02执行喽")
    # 对于fun02的定义者而言，不知道也不需要知道func的具体逻辑．
    func()

fun02(fun01)

list01 = [1,2,33,4,45,6]
# def find_demo01(target):
#     for item in target:
#         if item> 5:
#             yield item
#
# def find_demo02(target):
#     for item in target:
#         if item % 2 != 0:
#             yield item
#
# def find_demo03(target):
#     for item in target:
#         if item < 3:
#             yield item

# --------------------------------------------
# 相同点：
def find_demo(target,func):
    for item in target:
        # 本行代码，又将不变的与变化的紧密相连
        # if condition01(item):
        # 本行代码，使用形参func将不变的与变化的隔离开．
        if func(item):
            yield item
# --------------------------------------------
# 提取不同点：
def condition01(item):
    return item> 5

def condition02(item):
    return item % 2 != 0

def condition03(item):
    return item < 3

for item in find_demo(list01,condition03):
    print(item)

　　代码2：

　　

"""
    lambda 表达式(匿名方法)
    语法：　
    lambda　参数:方法体
    练习：
    exercise05.py
"""

def fun01():
    print("我是普通方法")

fun01()

def fun02(a):
    print("我是普通方法,参数是,", a)

fun02(500)

def fun03():
    return True

print(fun03())

# -------------------------
a01 = lambda: print("我是lambda方法")
a01()

a02 = lambda a: print("我是lambda方法,参数是,", a)
a02(500)

a03 = lambda: True
print(a03())
#------------------------------------

from common.custom_list_tools import ListHelper
list01 = [1,2,33,4,45,6]

for item in ListHelper.find_all(list01,lambda item:item > 5):
    print(item)

for item in ListHelper.find_all(list01,lambda item:item % 2 != 0):
    print(item)

# 提取不同点：
# def condition01(item):
#     return item> 5
#
# def condition02(item):
#     return item % 2 != 0
#
# def condition03(item):
#     return item < 3

# for item in ListHelper.find_all(list01,condition01):
#     print(item)

　　代码3：

　　

"""
    高阶函数

"""
from day16.common.custom_list_tools import ListHelper

# 敌人类（编号／姓名／攻击力／血量／攻击速度．．．）
class Enemy:
    def __init__(self, id, name, hp, atk, atk_speed):
        self.id = id
        self.name = name
        self.hp = hp
        self.atk = atk
        self.atk_speed = atk_speed

list01 = [
    Enemy(101, "玄冥大老", 200, 800, 5),
    Enemy(102, "玄冥小老", 150, 700, 3),
    Enemy(103, "qtx", 800, 1000, 50),
    Enemy(104, "吕泽玛利亚", 0, 300, 2),
    Enemy(105, "赵金多", 500, 900, 10),
]

# 1. filter 过滤，类似于ListHelper.find_all.
# 过滤出编号大于102的敌人
# for item in filter(lambda e: e.id > 102, list01):
#     print(item.id)
#
# for item in ListHelper.find_all(list01, lambda e: e.id > 102):
#     print(item.id)

# 2. map 映射，类似于ListHelper.select
# 映射出所有敌人的姓名
for item in map(lambda e:e.name,list01):
    print(item)

for item in ListHelper.select(list01,lambda e:e.name):
    print(item)

# # 按照血量升序排列,类似于ListHelper.order_by
# for item in sorted(list01,key = lambda e:e.hp ):
#     print(item.hp)
#
# # 按照血量降叙排列
# for item in sorted(list01,key = lambda e:e.hp,reverse=True):
#     print(item.hp)

# ListHelper.order_by(list01,lambda e:e.hp)
# for item in list01:
#     print(item.hp)

# 获取攻击力最大的敌人
result = max(list01,key = lambda e:e.atk)
print(result.name)

result = ListHelper.get_max(list01,lambda e:e.atk)
print(result.name)

　　代码4：

　　

"""
    Encolsing 外部嵌套作用域
"""

# 全局变量G
g01 = 100

def fun01():
    # fun01局部变量Ｌ
    # E外部嵌套作用域
    a = 1

    def fun02():
        b = 2 # fun02局部变量Ｌ
        # print("fun02:", a) # 可以访问外部嵌套变量a
        # a = 2222 # 没有修改外部嵌套变量a，而是创建了新的局部变量a
        # print("fun02:",a)
        nonlocal a # 声明外部嵌套变量a
        a = 2222
        print("fun02:",a)

    fun02()
    print("fun01:",a)

fun01()

　　代码5：

　　

"""
    闭包

"""

def fun01():
    print("fun01执行喽")
    a = 1
    def fun02():
        print("fun02执行喽")
        print("外部变量是:",a)
    return fun02

# 得到的是内部函数
result = fun01()
# 调用内部函数，因为内部函数使用了外部变量，所以称之为闭包．
result()# 可以使用外部变量，说明外部函数在调用后没有释放．

# 案例：

def give_gift_money(money):
    """
        获取压岁钱
    """
    print("得到了%d压岁钱"%money)
    def child_buy(target,price):
        """
            孩子需要买东西
        """
        nonlocal money
        if money >= price:
            money -= price
            print("孩子花了%d钱，买了%s,还剩下%d钱．"%(price,target,money))
        else:
            print("压岁钱不够了")
    return child_buy

action = give_gift_money(10000)
action("98k",3500)
action("小猪佩奇",300)
action("大黄蜂",8000)

# 体会：闭包使得逻辑连续（因为内部函数可以使用外部变量）．

　　代码6：

　　

"""
    装饰器
     -- 闭包的应用
"""

# def say_hello():
#     print("hello")
#
#
# def say_goodbye():
#     print("goodbye")
#
#
# say_hello()
# say_goodbye()

# 需求：在两个方法实现的功能基础上，增加新功能(打印方法名称)

# def say_hello():
#     print(say_hello.__name__)
#     print("hello")
#
#
# def say_goodbye():
#     print(say_goodbye.__name__)
#     print("goodbye")
#
#
# say_hello()
# say_goodbye()

# 缺点：代码重复.
# 解决：提取打印方法名称的功能

# def print_func_name(func):
#     print(func.__name__)
#
# def say_hello():
#     # print(say_hello.__name__)
#     print_func_name(say_hello)
#     print("hello")
#
#
# def say_goodbye():
#     # print(say_goodbye.__name__)
#     print_func_name(say_goodbye)
#     print("goodbye")

# say_hello()
# say_goodbye()
# 缺点：在两个已有功能的内部，增加新功能，代码可读性差．

# def say_hello():
#     # print_func_name(say_hello)
#     print("hello")

# def say_goodbye():
#     # print_func_name(say_goodbye)
#     print("goodbye")
#
# def print_func_name(func):
#     # 包装新旧功能
#     def wrapper():
#         # 增加的新功能
#         print(func.__name__)
#         # 旧功能
#         func()
#
#     return wrapper # 返回包装器
#
# say_hello = print_func_name(say_hello)
# say_goodbye = print_func_name(say_goodbye)
#
# say_hello()
# say_goodbye()

# 缺点：调用者完成包装新旧方法的任务．
# 解决：应该有定义者完成．

# def print_func_name(func):
#     # 包装新旧功能
#     def wrapper():
#         # 增加的新功能
#         print(func.__name__)
#         # 旧功能
#         func()
#
#     return wrapper # 返回包装器
#
# @print_func_name # say_hello = print_func_name(say_hello)
# def say_hello():
#     print("hello")
#     return "哈哈"
#
# @print_func_name
# def say_goodbye():
#     print("goodbye")
#
# #---------以上是定义者--以下是调用者-----------------
# say_hello()
# say_goodbye()

# 缺点：旧功能的返回值不能被客户端代码接受到．
#      旧功能的参数，客户端代码也无法传入.

# def print_func_name(func):
#     # 包装新旧功能
#     def wrapper(name):
#         # 增加的新功能
#         print(func.__name__)
#         # 旧功能
#         return func(name)
#
#     return wrapper # 返回包装器

# 缺点：包装器不能适应所有的旧功能参数
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(name):
    print(name,"hello")
    return "哈哈"

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

#---------以上是定义者--以下是调用者-----------------
print(say_hello("张无忌"))
say_goodbye("赵敏",25)

　　代码7：

　　

"""
    练习：使用装饰器实现：
    　　　为两个已有功能(进入后台，删除订单)，增加新功能（验证权限）.　
"""

# 1. 定义装饰器(新功能　＋　旧功能)

def verify_permissions(func):
    def wrapper(*args, **kwargs):
        print("验证权限")
        return func(*args, **kwargs)
    return wrapper

# 2. 拦截调用
@verify_permissions
def enter_background(loginId,pwd):
    print(loginId,pwd)
    print("进入后台系统.....")

@verify_permissions
def delete_order(order_id):
    print("删除%d订单..."%order_id)

enter_background("zs",123)
delete_order(101)

　　代码8：

　　

"""
    练习２：为两个已有功能(存款取款),添加新功能(验证账户)

"""
def verify_accont(func):
    def wrapper(*args,**kwargs):
        print("验证账户")
        return func(*args,**kwargs)
    return wrapper

#deposit = verify_accont(deposit)
@verify_accont
def deposit(money):
    print("存款:",money)

@verify_accont
def withdraw():
    print("取钱")
    return 10000

deposit(5000)
print(withdraw())

　　代码9：

　　

"""
    练习：
    　　　为学生的学习方法，添加新功能(打印执行时间)
"""

import time

def print_execute_time(func):
    def wrapper(*args, **kwargs):
        # 记录执行前的时间
        start_time = time.time()
        result = func(*args, **kwargs)
        # 统计执行时间
        execute_time = time.time() - start_time
        print("执行时间是：", execute_time)
        return result

    return wrapper

class Student:
    def __init__(self, name):
        self.name = name

    @print_execute_time
    def study(self):
        print("开始学习喽")
        time.sleep(2)  # 睡眠两秒　模拟学习了两秒

s01 = Student("无忌")
s01.study()