python函数的进阶

内容概要

• 名称空间的作用域

• global与nonlocal关键字使用

• 函数对象(函数名)

• 函数的嵌套调用

• 函数的嵌套定义

• 闭包函数(重点)

内容详细

名称空间

# 什么是名称空间(namespaces)
	用于存放变量名与变量值绑定关系的地方(类似于民政局)
    
# 名称空间的分类(重要)
	1.内置名称空间
    	python解释器提前给你定义好的
        	print()
            len()
            ...
	2.全局名称空间
    	在py文件中定个编写的代码运行之后都会存入全局名称空间
                name = 'jason'  # name全局
                def func():  # func全局
                    pass
                if 1:
                    a = 123  # a全局
                for i in range(10):
                    print(i)  # i全局
                while True:
                    a = 123  # a全局
	3.局部名称空间
    	函数体代码运行之后产生的都是局部名称空间

        # 存活周期
        	1.内置名称空间
            	python解释器启动与关闭而创建和销毁
            2.全局名称空间
            	随着py文件的运行与结束而创建和销毁
            3.局部名称空间
            	随着函数代码体的执行与结束而创建和销毁    

名字的查找顺序

# 在查找名字的时候 要先确认自己当前的位置
	1.如果你在局部
    局部>>>全局>>>内置
    2.如果你在全局
    全局>>>内置
    
# 局部名称空间的嵌套
'''函数在定义阶段名字的查找顺序就已经固定死了(特例)'''
x = 111
def f1():
    x = 222
    def f2():
        x = 333
        def f3():
            x = 444
            def f4():
                x = 555
                print(x)
                # x = 555(特例)
            f4()
        f3()
    f2()
f1()

名称空间的作用域

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

global与nonlocal关键字使用

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

# name_list = ['jason', 'tom']
# def index():
#     name_list.append('tony')
# index()
# print(name_list)  # ['jason', 'tom', 'tony']
"""
如果想在局部修改全局数据
	如果数据为不可变类型则需要关键字global声明
	如果数据为可变类型则无序关键字global声明
"""

# def index():
#     l1 = [11,22]
#     def func():
#         l1.append(33)
#     func()
#     print(l1)  # [11, 22, 33]
# index()

函数对象(函数名)

"""函数名遇到括号就会调用！！"""
# 用法1：函数名可以当做变量名赋值
def index():
    print('from index')
a = index
a()  # 本质就是在调用index函数

# 用法2: 函数名还可以当做函数的实参
# def index():
#     print('from index')
# def func(a):
#     print(a)
#     a()
#     print('from func')
# func(index)

# 用法3：函数名还可以当做函数返回值
def index():
    print('from index')
def func():
    print('from func')
    return index
res = func()
res()  # from func  from index

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

# 用法4：函数名可以当作容器类型(内部可以存放多个数据)的元素
# def index():
#     print('from index')
# l = [11,22,33,index()]
# print(l)  # [11, 22, 33, None]

# def index():
#     print('from index')
#     return {'name' : 'jason'}
# l = [11,22,33,index()]
# print(l)  # [11, 22, 33, {'name': 'jason'}]


# 定义函数
# 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('功能编号不存在')
#         # 类比之前写的代码功能较多时 代码过于复杂

函数的嵌套调用

# 嵌套调用：函数内部调用其他函数
# def index():
#     print('from index')
# def func():
#     index()
#     print('from func')
# func()  # from index  from func

# def my_max(a, b):
#     if a > b:
#         return a
#     return b
# print(my_max(10, 20))

def my_max(a, b):
#     if a > b:
#         return a
#     return b
# def many_max(x,y,z,w):
#     res = my_max(x,y)
#     res1 = my_max(z,w)
#     res2 = my_max(res,res1)
#     return res2
# print(many_max(2, 6, 1, 5))  # 6

函数嵌套的定义

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

闭包函数

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

def outer():
#     x = 222
#     def index():
#         print('from index', x)
#     return index
# res = outer()
# x = 333
# res()  # from index 222

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