名称空间的作用域、global和nonlocals关键字的使用、函数对象(函数名可以当成变量名、实参、返回值、容器类型的元素来使用)、函数的嵌套调用、闭包函数、装饰器(介绍)

一、名称空间的作用域

名称空间：
    作用域额：变量能够作用的范围
    1.内置的名称空间
        在程序的任何阶段任意位置都可以使用(全局有效)
    2. 全局名称空间
        在程序的任何阶段任意位置都可以使用(全局有效)
    3. 局部的名称空间
        在函数内部有效(局部有效)
        
    注意：
    局部的变量能不能在任何位置使用？局部变量一般都在函数的内部使用，外部一般不能使用
    在全局定义的变量我们称之为全局变量，全局变量在任何位置任何阶段都可以使用

二、global和nonlocals关键字的使用

'''
global的使用：
    在函数的内部不能直接修改外部的变量：
    1. 在函数内部修改外部的不可变类型的数据，需要使用 global 关键字声明
    2. 在函数的内部修改外部的可变类型的变量不需要使用global关键字
'''
# 外部不可变类型
x = 111
def index():
    global x
    x = 222

index()
print(x)  # 222

# 外部可变类型
name_list = ['kevin', 'jack']
def index():
    name_list.append('tony')

index()
print(name_list)  # ['kevin', 'jack', 'tony']


'''*************************************************'''

'''
nonlocal的使用：
    1. 在函数的内部的局部修改外部的局部的可变类型，要使用关键字 nonlocal 声明
    2. 在函数的内部的局部修改外部的局部的不可变类型，不需要使用关键字 nonlocal 声明
'''
# 外部的局部的不可变类型的数据
def outer():
    x = 1
    def inner():
        nonlocal x
        x = 2
    inner()
    print(x)

outer()  # 2

# 外部的局部的可变类型的数据
def outer():
    name_list = ['kevin','tank']
    def inner():
        name_list.append('tony')
    inner()
    print(name_list)

outer()  # ['kevin', 'tank', 'tony']

三、函数对象(函数名)

函数名的使用有四种方法

# 函数对象就是函数名
# 1.函数名可以当成变量名来使用
def index():  # index它是属于全局的
    print('index')
    
'''函数名就是函数的内存地址'''
# print(globals())
# 0x0000012096C4CD90 这一串value值就是函数的内存地址
print(index)  # <function index at 0x0000012096C4CD90>
index()  # 直接调用函数
a = index()
a()

# 2. 函数名可以当成函数的实参
def index():
    print('from index')
def func(func_name):
    print('from func')
    func_name()  # 相当于是index()
func(index)

# 3. 函数名也可以当成函数的返回值
def index():
    print('from index')
def func():
    print('from func')
    return index
return_value = func()  # return_value就是函数的内存地址
return_value()  # index()
print(return_value)

# 4.函数名也可以当成容器类型的元素
def index():
    print('from index')
# l = [1,2,3,index()]
# print(l)  # [1, 2, 3, None]
l = [1, 2, 3, index]
print(l)  # [1, 2, 3, <function index at 0x000001860D45CD90>]
l[3]()  # from index

案例

# 案例
def register():
    print('register')


def login():
    print('login')


def transfer():
    print('transfer')


def withdraw():
    print('login')


def shopping():
    print('shopping')


def other_func():
    print('other_func')


func_dict = {
    '1': register,
    '2': login,
    '3': transfer,
    '4': withdraw,
    '5': shopping,
    '6': other_func
}

while True:
    print("""
        1. 注册功能
        2. 登录功能
        3. 转账功能
        4. 提现功能
        5. 购物功能
        6. 其它功能
    """)

    choice = input('请输入你选择的序号>>>:').strip()
    if choice in func_dict():
        # func_name = func_dict.get(choice)
        # func_name()
        func_dict.get(choice)()

四、函数的嵌套调用

# 函数之间互相调用，函数里面调用函数
# 使用场景
# 1.定义一个函数，比较两个功能的大小
def my_max(a, b):
    if a > b:
        return a
    return b

res = my_max(1, 10)
print('输出的结果是：', res)  # 输出的结果是： 10


# 2. 定义一个函数，比较4个数的大小
def my_max(a, b):
    if a > b:
        return a
    return b
def many_max(a, b, c, d):
    res = my_max(a, b)  # res是a和b中的最大
    res1 = my_max(res, c)  # res1是abc中的最大
    res2 = my_max(res1, d)  # res2是abcd中的最大
    return res2
return_max = many_max(3, 5, 6, 2)
print(return_max)

五、函数的嵌套定义(了解)

# 给外部的用户暴露出来一个接口，告诉他都有什么功能
def all_func(type):
    def login():
        print('login')

    def transfer():
        print('login')

    def withdraw():
        print('login')

    def shopping():
        print('login')

    def shopping1():
        print('login')

    if type == 1:
        login()
    elif type == 2:
        transfer()
    elif type == 3:
        withdraw()
    elif type == 4:
        shopping()


all_func(1)
all_func(2)
all_func(3)

六、闭包函数

'''
1.什么是闭包函数？
    闭：就是函数内部定义函数，至少两层函数
    包：内部的函数使用外部函数名称空间的名字
    
2.注意：只有满足同时满足以上两个条件才能称之为是闭包函数
    闭包函数其实就是给函数传参的第二种方式

'''

# 方式1：
def outer():
    a = 20
    b = 10
    def my_max():
        if a > b:
            return a
        return b
    return my_max
res = outer()
print(res())  # 20

# 爬虫：爬取网页上的数据
import requests

def outer(url):

    def get_content():
        res = requests.get(url)
        with open('baidu.html', 'wb') as f:
            f.write(res.content)
    return get_content


res = outer('https://www.jd.com')
res()

七、装饰器(难点、重点)

"""
装饰器：
    是名称空间、闭包函数、函数嵌套等知识点汇总而来的知识点

    什么是装饰器：
        器：就是工具
        装饰：给被装饰的对象添加额外的功能
    装饰器的核心思想：
        就是在'不改变被装饰对象'内部的代码和'原有调用方式'的基础上再'添加额外的功能'
"""


# 时间模块
import time

def index():
    time.sleep(3)
    print('from index')

# 1.在函数执行之前打印一个时间点
start_time = time.time()
# 2.调用函数
index()
# 3.在两者执行完毕之后再打印一个时间点
end_time = time.time()
# 4.两者之间的时间差就是函数的执行时间
print('index函数一共执行了%s秒' % (end_time - start_time))