Python的名称空间与函数嵌套

Python的名称空间与函数嵌套

• 名称空间的作用域
• global与nonlocal关键字的使用
• 函数对象（函数名）
• 函数的嵌套调用
• 函数的嵌套定义
• 闭包函数

一、名称空间的作用域

　　1. 作用域

　　　　名称空间所能够作用的范围

　　2. 内置名称空间

　　　　程序任何阶段任何位置均可使用（全局有效）

　　3. 全局名称空间

　　　　程序任何阶段任何位置均可使用（全局有效）

　　4. 局部名称空间

　　　　一般情况下只有在各自的局部名称空间中有效

二、global与nonlocal关键字的使用

　　1. global关键字

　　　　在局部修改全局数据，如果数据类型为不可变类型则需要关键字global声明。

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

　　　　如果数据为可变类型则无需关键字global声明。

name_list = ['aaa', 'bbb']
def index():
    name_list.append('ccc')
index()
print(name_list)

 　　2. nonlocal关键字

　　　　在内部的局部修改外部局部名称空间中的不可变类型，需要关键字nonlocal声明。

def index():
    x = 111
    def func():
        nonlocal x
        x = 222  # 内部局部修改外部局部
    func()
    print(x)
index()

 　　　　如果是可变类型则不需要关键字nonlocal声明。

def index():
    l1 = [11, 22]
    def func():
        l1.append(333)  # 内部局部修改外部局部
    func()
    print(l1)
index()

 

 三、函数对象（函数名）

　　函数名遇到括号就会调用！！！

　　1. 函数名可以当做变量名赋值

def index():
    print('from index')
a = index
a()  # 本质就是在调用index函数

 　　2. 函数名可以当做函数的实参

def index():
    print('from index')
def func(a):
    a()
func(index)

　　3. 函数名可以当做函数返回值

def index():
    print('from index')
def func():
    return index
res = func()  # 调用func并接受func的返回值
res()

 　　4. 函数名可以当做容器类型(内部可以存放多个数据)的元素

def index():
    print('from index')
l = [111, 222, 333, index()]
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('功能编号不存在')

　　　　下列代码的弊端在于功能较多时，代码过于复杂

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()
    if choice == '1':
        register()
    elif choice == '2':
        login()
    elif choice == '3':
        shopping()
    elif choice == '4':
        transfer()
    elif choice == '5':
        withdraw()
    elif choice == '6':
        check_order()
    else:
        print('功能编号不存在')

四、函数的嵌套调用

　　1. 嵌套调用的概念

　　　　函数内部调用其他函数

def index():
    print('from index')

def func():
    index()
    print('from func')

func()

　　2. 函数嵌套调用实现比数字大小

def my_max(a, b):
    if a > b:
        return a
    return b

def many_max(x, y, z, m):
    res = my_max(x, y)
    res1 = my_max(res, z)
    res2 = my_max(res1, m)
    return res2

ret = many_max(5, 2, 9, 4)
print(ret)

五、函数的嵌套定义

　　1. 函数嵌套定义的概念

　　　　函数体内部定义其它函数

　　　　函数嵌套定义的好处是能将复杂的功能全部隐藏起来，仅暴露一个简单的接口。

　　2. 函数嵌套定义演示

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')

六、闭包函数

　　1. 闭包函数的概念

　　　　闭：定义在函数内部的函数

　　　　包：内部函数使用了外部函数名称空间中的名字

　　　　只有符合上述两个特征的函数才可以称之为“闭包函数”

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

　　2. 闭包函数的使用

　　　　闭包函数其实是给函数传参的第二种方式。

　　　　方式1：函数体代码需要用到数据，直接在括号内定义即可

def index(username):
    print(username)


def my_max(a, b):
    if a > b:
        return a
    return b

　　　　方式2：利用闭包函数

def outer(x, y):
    # x = 2
    # y = 40
    def my_max():
        if x > y:
            return x
        return y
    return my_max

res = outer(2, 40)
print(res())
print(res())

　　　　这种方式的好处是传入一次值后，之后调用无需再传值。