python之函数二

global和nonlocal关键字的使用

# x = 111
#
#
# def index():
#     # 局部修改全局的变量
#     global x
#     x = 222
#
#
# index()
# print(x)


# name_list = [11, 22]
#
#
# def index():
#     # 局部修改全局的变量
#     name_list.append(33)
#
#
# index()
# print(name_list)
'''
    在局部修改全局的变量：
        1. 修改的变量时不可变的类型，需要global关键字声明
        2. 修改的变量是可变的类型，不需要global关键字声明
'''


def index():
    # x = 222
    name_list = [1, 2, 3]

    def func():
        # 内部的局部修改外部的局部的变量
        # nonlocal x
        # x = 333
        name_list.append(4)
    func()
    print(name_list)


index()

函数对象（函数名）

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


# 函数名
# 玩法1：函数名可以当成变量赋值
# def index():
#     print('from index')
#
# a = index
# a()
# print(a)  # 函数名就是内存地址


# 玩法2：函数名可以当成函数的参数
# def index():
#     print('from index')
#
#
# def func(a):
#     # a => index
#     a()
#     print('from func')
#
#
# func(index)

# 玩法3：函数名也可以当成函数的返回值
# def index():
#     print('from index')
#
#
# def func():
#     print('from func')
#     return index
#
# res = func()
# res()

# 玩法4：函数名也可以当成容器(可以存放多个元素)类型的元素
# def index():
#     print('from index')
#
#
# l = [1, 2, 3, index]
# print(l)

# 小案例
# 注册功能
def register():
    print('注册')


# 登录功能
def login():
    print('登录')


# 转账功能
def transfer():
    print('转账')


# 购物功能
def shopping():
    print('购物')


# 提现功能
def withdraw():
    print('提现')


func_dict = {
    '1': register,
    '2': login,
    '3': transfer,
    '4': shopping,
    '5': withdraw
}
while True:
    print("""
        1. 注册
        2. 登录
        3. 转账
        4. 购物
        5. 提现
    """)

    choice = input('请输入序号：>>>').strip()
    if choice in func_dict:
        func_name = func_dict[choice]  # 得到的就是函数的内存地址，函数名
        func_name()
    else:
        print('请好好输入')
    
    # 一下方式太复杂了，优化一下
    # if choice == '1':
    #     register()
    # elif choice == '2':
    #     login()
    # elif choice == '3':
    #     transfer()
    # elif choice == '4':
    #     shopping()
    # elif choice == '5':
    #     withdraw()
    # else:
    #     print('请好好输入')

函数的嵌套调用

# 函数里面调用其他函数

# 实际应用
# 1.比较两个数的大小
def my_max(a, b):
    if a > b:
        return a
    return b


# my_max(1, 2)


# 2. 比较4个数的大小
def many_max(a, b, c, d):
    # 先两两比较，a,b
    res = my_max(a, b)
    res1 = my_max(res, c)
    res2 = my_max(res1, d)
    return res2

print(many_max(1,2,3,4))

函数的嵌套定义

# 在函数里面定义其他函数
# 把复杂的功能隐藏起来了
def all_func(type):
    def register():
        print('注册')

    def login():
        print('登录')

    def transfer():
        print('转账')

    def withdraw():
        print('提现')

    if type == 1:
        register()
    elif type == 2:
        login()
    elif type == 3:
        transfer()
    elif type == 4:
        withdraw()
    else:
        print('好好输入')


# all_func(1)
all_func(2)

闭包函数

闭：
	定义在函数内部的函数
包：
	内部函数必须使用外部函数的数据
# 只有符合以上两个条件的函数才称之为闭包函数
# 第二种传参方式：闭包函数
def outer(a, b):
    # a = 1
    # b = 10

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

res = outer(2, 20) # res => my_max的内存地址
print(res())  # my_max()
print(res())  # my_max()
print(res())
print(res())
print(res())

装饰器的概念（重点）

'''
	装饰器不是一个新的知识，而是名称空间，闭包函数等等的组合就是装饰器
'''

装饰：给函数增加额外的功能
器：就是工具


装饰器的核心思想：在"不改变原有函数的代码"和"原有调用方式"的基础上"增加额外"的功能

def index():
    pass

index()

'''给index函数统计执行时间'''

储备知识：
	time模块
    import time  # 模块


# 1. 时间戳， 它是执行的这一刻距离1970-1-1 的秒数
# print(time.time())  # 1641528030.2125015

# 2. 在原地等待3秒
# time.sleep(3)
# print(123)

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

# 1. 在函数执行之前打印一个时间节点
start_time = time.time()
index()

# 2. 等待函数执行完毕之后，在打印一个时间节点
end_time = time.time()

# 3. 总的执行时间就是两个的差值
print(end_time - start_time)