函数对象与闭包函数相关知识

目录

• 今日内容概要
  • 内容详细
    • • • • 名称空间的作用域
          • global 与 nonlocal 关键字的使用
          • 函数对象（函数名）
          • 函数的嵌套使用
          • 函数的嵌套含义
          • 闭包函数
          • 装饰器

今日内容概要

• 名称空间的作用域
• global 与 nonlocal 关键字使用
• 函数对象（函数名）
• 函数的嵌套调用
• 函数的嵌套定义
• 闭包函数
• 装饰器概念（简单接触）

内容详细

• 名称空间的作用域

# 作用域
	名称空间能够作用的范围
    
# 内置名称空间
	程序任何阶段任何位置都能使用（全局有效）
    
# 全局名称空间
	程序任何阶段任何位置都能使用（全局有效）
    
# 局部名称空间
	一般情况下 只在各自的局部名称空间中有效

• global 与 nonlocal 关键字的使用

# global

"""局部修改全局变量 需要使用关键字声明"""
x = 111  # 1
def index():  # 2
    global x  # 4  
    x = 222  # 5
index()  # 3
print(x)  # 6  x = 222

name_list = ['jason', 'kevin']  # 1
def index():  # 2
    name_list.append('heiheihei')  # 4
index()  # 3
print(name_list)  # 5
# 如果在局部修改全局数据
	如果数据为不可变类型 则需要使用关键字 global 声明
	如果数据为可变类型 则无需使用关键字 global 声明
    
    
    
def index():  # 1
    # x = 111
    l1 = [11,22]  # 3
    def func():  # 4
        # 内部局部修改外部局部
        l1.append(333)  # 6
    func()  # 5
    print(l1)  # 7
index()  # 2
# 如果想要在内部的局部修改外部局部的不可变数据类型
	需要关键字nonlocal声明

• 函数对象（函数名）

"""
函数名遇到括号就会调用 无论写在哪个位置
"""
# 用法1
	函数名可以当作变量名赋值
def index():
    print('from index')
a = index
a()  #  a()就相当于index()  本质就是在调用index函数

# 用法2
	函数名还可以当作函数的实参
def index():  # 1
    print('from index')  # 6	打印结果二：from index
def func(a):  # 2
    print(a)  # 4	打印结果一：<function index at 0x000001F61374E268>
    a()  # 5  # 7
    print('from func')  # 8		打印结果三：from func
func(index)  # 3  # 9

# 用法3
	函数名还可以当作函数返回值
def index():  # 1
    print('from index')  # 8
def func():  # 2
    print('from func')  # 4
    return index  # 5
res = func()  # 3 调用func并接受func的返回值  # 6
res()  # 7  # 9

# 用法4
	函数名可以当做容器类型(内部可以存放多个数据)的元素
def index():  # 1
    print('from index')  # 3
l = [111, 222, 333, index()]  # 2   # 4
print(l)  # 5


封装：
def register():
    print('注册功能')
def login():
    print('登录功能')
def shopping():
    print('购物功能')
def transfer():
    print('转账功能')
def withdraw():
    print('提现功能')
def check_order():
    print('查看订单')
func_dic = {'1':register,
            '2':login,
            '3':shopping,
            '4':transfer,
            '5':withdraw,
            '6':check_order
            }
while True:
    print("""
    1.注册功能
    2.登录功能
    3.购物功能
    4.转账功能
    5.提现功能
    6.查看订单
    """)
    choice = input('请输入功能编号>>>:').strip()
    # 判断用户输入的编号在不在字典的k中
    if choice in func_dic:
        # 根据键获取值(函数名)
        func_name = func_dic.get(choice)
        # 函数名加括号调用
        func_name()
    else:
        print('功能编号不存在')
        
                     
# 下列代码的弊端在于功能较多时 代码过于复杂
    if choice == '1':
        register()
    elif choice == '2':
        login()
    elif choice == '3':
        shopping()
    else:
        print('写累了')

• 函数的嵌套使用

# 嵌套调用：函数内部调用其他函数
def index():  # 1
    print('from index')  # 5
def func():  # 2
    index()  # 4    # 6
    print('from func')  # 7
func()  # 3     # 8



def my_max(a, b):  # 1
    if a > b:  # 5      # 9     # 13
        return a
    return b  # 6   # 10    # 14
def many_max(x,y,z,m):  # 2
    res = my_max(x,y)  # 4     # 7
    res1 = my_max(res,z)  # 8   # 11
    res2 = my_max(res1,m)  # 12      # 15
    return res2  # 16
ret = many_max(1,2,3,4)  # 3    # 17
print(ret)  # 18

• 函数的嵌套含义

# 函数体内部定义其他函数
# 将复杂的功能全部隐藏起来 暴露一个简单的接口
def all_func(type):
    def register():
        print('注册功能')
    def login():
        print('登录功能')
    def transfer():
        print('转账功能')
    def shopping():
        print('购物功能')
    # 这里仅仅是演示嵌套定义的现象 暂不考虑优化
    if type == '1':
        register()
    elif type == '2':
        login()
    elif type == '3':
        transfer()
    elif type == '4':
        shopping()
    else:
        print('不知道啥功能')
all_func('3')

• 闭包函数

# 闭：定义在函数内部的函数
# 包：内部函数使用了外部函数的名称空间中的名字
"""
只有符合上述两个特征的函数才可以称之为'闭包函数'
"""
def outer():
    x = 222
    def index():
        print('from index', x)
    return index

# 闭包函数其实是给函数传参的第二种方式
方式1:
    函数体代码需要用到数据 直接在括号内定义形参即可
def index(username):
    print(username)
def my_max(a, b):
    if a > b:
        return a
    return b

方式2:
    利用闭包函数
def outer(x, y):  # 1
    def my_max():  # 3
        if x > y:  # 7
            return x
        return y  # 8
    return my_max  # 4
res = outer(2, 40)  # 2      # 5
print(res())  # 6   #9

• 装饰器

"""
装饰器是由 名称空间 函数对象 闭包函数组合而来
"""
# 装饰:给被装饰的对象添加额外的功能
# 器:指的是工具

装饰器原则
	开放封闭原则
    	开放:对扩展开放
    	封闭:对修改封闭
            
            
装饰器核心思想
	在不改变'装饰对象内部代码'和'原有调用方式'的基础之上添加额外功能
    
def index():
	print('from index')
index()


# 统计index函数的执行时间
import time
# print(time.time())  # 1637036293.0609405
# 获取的结果叫时间戳(运行代码的那一刻距离1970-1-1所经历的秒数)
# time.sleep(3)  # 让程序原地等待3秒
# print('睡饱了')
def index():
    time.sleep(3)
    print('from index')
# 统计index函数的执行时间
# 在函数运行之前统计一次时间
start_time = time.time()
index()
# 在函数运行完毕之后再次统计
end_time = time.time()
# 计算差值
print(end_time - start_time)